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 17package xiangshan.frontend 18 19import org.chipsalliance.cde.config.Parameters 20import freechips.rocketchip.rocket.{RVCDecoder, ExpandedInstruction} 21import chisel3.{util, _} 22import chisel3.util._ 23import utils._ 24import utility._ 25import xiangshan._ 26import xiangshan.frontend.icache._ 27import xiangshan.backend.decode.isa.predecode.PreDecodeInst 28import java.lang.reflect.Parameter 29 30trait HasPdConst extends HasXSParameter with HasICacheParameters with HasIFUConst{ 31 def isRVC(inst: UInt) = (inst(1,0) =/= 3.U) 32 def isLink(reg:UInt) = reg === 1.U || reg === 5.U 33 def brInfo(instr: UInt) = { 34 val brType::Nil = ListLookup(instr, List(BrType.notCFI), PreDecodeInst.brTable) 35 val rd = Mux(isRVC(instr), instr(12), instr(11,7)) 36 val rs = Mux(isRVC(instr), Mux(brType === BrType.jal, 0.U, instr(11, 7)), instr(19, 15)) 37 val isCall = (brType === BrType.jal && !isRVC(instr) || brType === BrType.jalr) && isLink(rd) // Only for RV64 38 val isRet = brType === BrType.jalr && isLink(rs) && !isCall 39 List(brType, isCall, isRet) 40 } 41 def jal_offset(inst: UInt, rvc: Bool): UInt = { 42 val rvc_offset = Cat(inst(12), inst(8), inst(10, 9), inst(6), inst(7), inst(2), inst(11), inst(5, 3), 0.U(1.W)) 43 val rvi_offset = Cat(inst(31), inst(19, 12), inst(20), inst(30, 21), 0.U(1.W)) 44 val max_width = rvi_offset.getWidth 45 SignExt(Mux(rvc, SignExt(rvc_offset, max_width), SignExt(rvi_offset, max_width)), XLEN) 46 } 47 def br_offset(inst: UInt, rvc: Bool): UInt = { 48 val rvc_offset = Cat(inst(12), inst(6, 5), inst(2), inst(11, 10), inst(4, 3), 0.U(1.W)) 49 val rvi_offset = Cat(inst(31), inst(7), inst(30, 25), inst(11, 8), 0.U(1.W)) 50 val max_width = rvi_offset.getWidth 51 SignExt(Mux(rvc, SignExt(rvc_offset, max_width), SignExt(rvi_offset, max_width)), XLEN) 52 } 53 54 def NOP = "h4501".U(16.W) 55} 56 57object BrType { 58 def notCFI = "b00".U 59 def branch = "b01".U 60 def jal = "b10".U 61 def jalr = "b11".U 62 def apply() = UInt(2.W) 63} 64 65object ExcType { //TODO:add exctype 66 def notExc = "b000".U 67 def apply() = UInt(3.W) 68} 69 70class PreDecodeInfo extends Bundle { // 8 bit 71 val valid = Bool() 72 val isRVC = Bool() 73 val brType = UInt(2.W) 74 val isCall = Bool() 75 val isRet = Bool() 76 //val excType = UInt(3.W) 77 def isBr = brType === BrType.branch 78 def isJal = brType === BrType.jal 79 def isJalr = brType === BrType.jalr 80 def notCFI = brType === BrType.notCFI 81} 82 83class PreDecodeResp(implicit p: Parameters) extends XSBundle with HasPdConst { 84 val pd = Vec(PredictWidth, new PreDecodeInfo) 85 val hasHalfValid = Vec(PredictWidth, Bool()) 86 //val expInstr = Vec(PredictWidth, UInt(32.W)) 87 val instr = Vec(PredictWidth, UInt(32.W)) 88 val jumpOffset = Vec(PredictWidth, UInt(XLEN.W)) 89// val hasLastHalf = Bool() 90 val triggered = Vec(PredictWidth, new TriggerCf) 91} 92 93class PreDecode(implicit p: Parameters) extends XSModule with HasPdConst{ 94 val io = IO(new Bundle() { 95 val in = Input(new IfuToPreDecode) 96 val out = Output(new PreDecodeResp) 97 }) 98 99 val data = io.in.data 100// val lastHalfMatch = io.in.lastHalfMatch 101 val validStart, validEnd = Wire(Vec(PredictWidth, Bool())) 102 val h_validStart, h_validEnd = Wire(Vec(PredictWidth, Bool())) 103 104 val validStart_half, validEnd_half = Wire(Vec(PredictWidth, Bool())) 105 val h_validStart_half, h_validEnd_half = Wire(Vec(PredictWidth, Bool())) 106 107 val validStart_halfPlus1, validEnd_halfPlus1 = Wire(Vec(PredictWidth, Bool())) 108 val h_validStart_halfPlus1, h_validEnd_halfPlus1 = Wire(Vec(PredictWidth, Bool())) 109 110 val validStart_diff, validEnd_diff = Wire(Vec(PredictWidth, Bool())) 111 val h_validStart_diff, h_validEnd_diff = Wire(Vec(PredictWidth, Bool())) 112 113 val currentIsRVC = Wire(Vec(PredictWidth, Bool())) 114 115 validStart_half.map(_ := false.B) 116 validEnd_half.map(_ := false.B) 117 h_validStart_half.map(_ := false.B) 118 h_validEnd_half.map(_ := false.B) 119 120 validStart_halfPlus1.map(_ := false.B) 121 validEnd_halfPlus1.map(_ := false.B) 122 h_validStart_halfPlus1.map(_ := false.B) 123 h_validEnd_halfPlus1.map(_ := false.B) 124 125 val rawInsts = if (HasCExtension) VecInit((0 until PredictWidth).map(i => Cat(data(i+1), data(i)))) 126 else VecInit((0 until PredictWidth).map(i => data(i))) 127 128 for (i <- 0 until PredictWidth) { 129 val inst = WireInit(rawInsts(i)) 130 //val expander = Module(new RVCExpander) 131 currentIsRVC(i) := isRVC(inst) 132 val currentPC = io.in.pc(i) 133 //expander.io.in := inst 134 135 val brType::isCall::isRet::Nil = brInfo(inst) 136 val jalOffset = jal_offset(inst, currentIsRVC(i)) 137 val brOffset = br_offset(inst, currentIsRVC(i)) 138 139 io.out.hasHalfValid(i) := h_validStart(i) 140 141 io.out.triggered(i) := DontCare//VecInit(Seq.fill(10)(false.B)) 142 143 144 io.out.pd(i).valid := validStart(i) 145 io.out.pd(i).isRVC := currentIsRVC(i) 146 147 // for diff purpose only 148 io.out.pd(i).brType := brType 149 io.out.pd(i).isCall := isCall 150 io.out.pd(i).isRet := isRet 151 152 //io.out.expInstr(i) := expander.io.out.bits 153 io.out.instr(i) :=inst 154 io.out.jumpOffset(i) := Mux(io.out.pd(i).isBr, brOffset, jalOffset) 155 } 156 157 // the first half is always reliable 158 for (i <- 0 until PredictWidth / 2) { 159 val lastIsValidEnd = if (i == 0) { true.B } else { validEnd(i-1) || !HasCExtension.B } 160 validStart(i) := (lastIsValidEnd || !HasCExtension.B) 161 validEnd(i) := validStart(i) && currentIsRVC(i) || !validStart(i) || !HasCExtension.B 162 163 //prepared for last half match 164 val h_lastIsValidEnd = if (i == 0) { false.B } else { h_validEnd(i-1) || !HasCExtension.B } 165 h_validStart(i) := (h_lastIsValidEnd || !HasCExtension.B) 166 h_validEnd(i) := h_validStart(i) && currentIsRVC(i) || !h_validStart(i) || !HasCExtension.B 167 } 168 169 for (i <- 0 until PredictWidth) { 170 val lastIsValidEnd = if (i == 0) { true.B } else { validEnd_diff(i-1) || !HasCExtension.B } 171 validStart_diff(i) := (lastIsValidEnd || !HasCExtension.B) 172 validEnd_diff(i) := validStart_diff(i) && currentIsRVC(i) || !validStart_diff(i) || !HasCExtension.B 173 174 //prepared for last half match 175 val h_lastIsValidEnd = if (i == 0) { false.B } else { h_validEnd_diff(i-1) || !HasCExtension.B } 176 h_validStart_diff(i) := (h_lastIsValidEnd || !HasCExtension.B) 177 h_validEnd_diff(i) := h_validStart_diff(i) && currentIsRVC(i) || !h_validStart_diff(i) || !HasCExtension.B 178 } 179 180 // assume PredictWidth / 2 is a valid start 181 for (i <- PredictWidth / 2 until PredictWidth) { 182 val lastIsValidEnd = if (i == PredictWidth / 2) { true.B } else { validEnd_half(i-1) || !HasCExtension.B } 183 validStart_half(i) := (lastIsValidEnd || !HasCExtension.B) 184 validEnd_half(i) := validStart_half(i) && currentIsRVC(i) || !validStart_half(i) || !HasCExtension.B 185 186 //prepared for last half match 187 val h_lastIsValidEnd = if (i == PredictWidth / 2) { true.B } else { h_validEnd_half(i-1) || !HasCExtension.B } 188 h_validStart_half(i) := (h_lastIsValidEnd || !HasCExtension.B) 189 h_validEnd_half(i) := h_validStart_half(i) && currentIsRVC(i) || !h_validStart_half(i) || !HasCExtension.B 190 } 191 192 // assume PredictWidth / 2 + 1 is a valid start (and PredictWidth / 2 is last half of RVI) 193 for (i <- PredictWidth / 2 + 1 until PredictWidth) { 194 val lastIsValidEnd = if (i == PredictWidth / 2 + 1) { true.B } else { validEnd_halfPlus1(i-1) || !HasCExtension.B } 195 validStart_halfPlus1(i) := (lastIsValidEnd || !HasCExtension.B) 196 validEnd_halfPlus1(i) := validStart_halfPlus1(i) && currentIsRVC(i) || !validStart_halfPlus1(i) || !HasCExtension.B 197 198 //prepared for last half match 199 val h_lastIsValidEnd = if (i == PredictWidth / 2 + 1) { true.B } else { h_validEnd_halfPlus1(i-1) || !HasCExtension.B } 200 h_validStart_halfPlus1(i) := (h_lastIsValidEnd || !HasCExtension.B) 201 h_validEnd_halfPlus1(i) := h_validStart_halfPlus1(i) && currentIsRVC(i) || !h_validStart_halfPlus1(i) || !HasCExtension.B 202 } 203 validStart_halfPlus1(PredictWidth / 2) := false.B // could be true but when true we select half, not halfPlus1 204 validEnd_halfPlus1(PredictWidth / 2) := true.B 205 206 // assume h_PredictWidth / 2 is an end 207 h_validStart_halfPlus1(PredictWidth / 2) := false.B // could be true but when true we select half, not halfPlus1 208 h_validEnd_halfPlus1(PredictWidth / 2) := true.B 209 210 // if PredictWidth / 2 - 1 is a valid end, PredictWidth / 2 is a valid start 211 for (i <- PredictWidth / 2 until PredictWidth) { 212 validStart(i) := Mux(validEnd(PredictWidth / 2 - 1), validStart_half(i), validStart_halfPlus1(i)) 213 validEnd(i) := Mux(validEnd(PredictWidth / 2 - 1), validEnd_half(i), validEnd_halfPlus1(i)) 214 h_validStart(i) := Mux(h_validEnd(PredictWidth / 2 - 1), h_validStart_half(i), h_validStart_halfPlus1(i)) 215 h_validEnd(i) := Mux(h_validEnd(PredictWidth / 2 - 1), h_validEnd_half(i), h_validEnd_halfPlus1(i)) 216 } 217 218 val validStartMismatch = Wire(Bool()) 219 val validEndMismatch = Wire(Bool()) 220 val validH_ValidStartMismatch = Wire(Bool()) 221 val validH_ValidEndMismatch = Wire(Bool()) 222 223 validStartMismatch := validStart.zip(validStart_diff).map{case(a,b) => a =/= b}.reduce(_||_) 224 validEndMismatch := validEnd.zip(validEnd_diff).map{case(a,b) => a =/= b}.reduce(_||_) 225 validH_ValidStartMismatch := h_validStart.zip(h_validStart_diff).map{case(a,b) => a =/= b}.reduce(_||_) 226 validH_ValidEndMismatch := h_validEnd.zip(h_validEnd_diff).map{case(a,b) => a =/= b}.reduce(_||_) 227 228 XSError(validStartMismatch, p"validStart mismatch\n") 229 XSError(validEndMismatch, p"validEnd mismatch\n") 230 XSError(validH_ValidStartMismatch, p"h_validStart mismatch\n") 231 XSError(validH_ValidEndMismatch, p"h_validEnd mismatch\n") 232 233// io.out.hasLastHalf := !io.out.pd(PredictWidth - 1).isRVC && io.out.pd(PredictWidth - 1).valid 234 235 for (i <- 0 until PredictWidth) { 236 XSDebug(true.B, 237 p"instr ${Hexadecimal(io.out.instr(i))}, " + 238 p"validStart ${Binary(validStart(i))}, " + 239 p"validEnd ${Binary(validEnd(i))}, " + 240 p"isRVC ${Binary(io.out.pd(i).isRVC)}, " + 241 p"brType ${Binary(io.out.pd(i).brType)}, " + 242 p"isRet ${Binary(io.out.pd(i).isRet)}, " + 243 p"isCall ${Binary(io.out.pd(i).isCall)}\n" 244 ) 245 } 246} 247 248class IfuToF3PreDecode(implicit p: Parameters) extends XSBundle with HasPdConst { 249 val instr = Vec(PredictWidth, UInt(32.W)) 250} 251 252class F3PreDecodeResp(implicit p: Parameters) extends XSBundle with HasPdConst { 253 val pd = Vec(PredictWidth, new PreDecodeInfo) 254} 255class F3Predecoder(implicit p: Parameters) extends XSModule with HasPdConst { 256 val io = IO(new Bundle() { 257 val in = Input(new IfuToF3PreDecode) 258 val out = Output(new F3PreDecodeResp) 259 }) 260 io.out.pd.zipWithIndex.map{ case (pd,i) => 261 pd.valid := DontCare 262 pd.isRVC := DontCare 263 pd.brType := brInfo(io.in.instr(i))(0) 264 pd.isCall := brInfo(io.in.instr(i))(1) 265 pd.isRet := brInfo(io.in.instr(i))(2) 266 } 267 268} 269 270class RVCExpander(implicit p: Parameters) extends XSModule { 271 val io = IO(new Bundle { 272 val in = Input(UInt(32.W)) 273 val out = Output(new ExpandedInstruction) 274 }) 275 276 if (HasCExtension) { 277 io.out := new RVCDecoder(io.in, XLEN, useAddiForMv = true).decode 278 } else { 279 io.out := new RVCDecoder(io.in, XLEN, useAddiForMv = true).passthrough 280 } 281} 282 283/* --------------------------------------------------------------------- 284 * Predict result check 285 * 286 * --------------------------------------------------------------------- 287 */ 288 289object FaultType { 290 def noFault = "b000".U 291 def jalFault = "b001".U //not CFI taken or invalid instruction taken 292 def retFault = "b010".U //not CFI taken or invalid instruction taken 293 def targetFault = "b011".U 294 def notCFIFault = "b100".U //not CFI taken or invalid instruction taken 295 def invalidTaken = "b101".U 296 def apply() = UInt(3.W) 297} 298 299class CheckInfo extends Bundle { // 8 bit 300 val value = UInt(3.W) 301 def isjalFault = value === FaultType.jalFault 302 def isRetFault = value === FaultType.retFault 303 def istargetFault = value === FaultType.targetFault 304 def invalidTakenFault = value === FaultType.invalidTaken 305 def notCFIFault = value === FaultType.notCFIFault 306} 307 308class PredCheckerResp(implicit p: Parameters) extends XSBundle with HasPdConst { 309 //to Ibuffer write port (stage 1) 310 val stage1Out = new Bundle{ 311 val fixedRange = Vec(PredictWidth, Bool()) 312 val fixedTaken = Vec(PredictWidth, Bool()) 313 } 314 //to Ftq write back port (stage 2) 315 val stage2Out = new Bundle{ 316 val fixedTarget = Vec(PredictWidth, UInt(VAddrBits.W)) 317 val jalTarget = Vec(PredictWidth, UInt(VAddrBits.W)) 318 val fixedMissPred = Vec(PredictWidth, Bool()) 319 val faultType = Vec(PredictWidth, new CheckInfo) 320 } 321} 322 323 324class PredChecker(implicit p: Parameters) extends XSModule with HasPdConst { 325 val io = IO( new Bundle{ 326 val in = Input(new IfuToPredChecker) 327 val out = Output(new PredCheckerResp) 328 }) 329 330 val (takenIdx, predTaken) = (io.in.ftqOffset.bits, io.in.ftqOffset.valid) 331 val predTarget = (io.in.target) 332 val (instrRange, instrValid) = (io.in.instrRange, io.in.instrValid) 333 val (pds, pc, jumpOffset) = (io.in.pds, io.in.pc, io.in.jumpOffset) 334 335 val jalFaultVec, retFaultVec, targetFault, notCFITaken, invalidTaken = Wire(Vec(PredictWidth, Bool())) 336 337 /** remask fault may appear together with other faults, but other faults are exclusive 338 * so other f ault mast use fixed mask to keep only one fault would be found and redirect to Ftq 339 * we first detecct remask fault and then use fixedRange to do second check 340 **/ 341 342 //Stage 1: detect remask fault 343 /** first check: remask Fault */ 344 jalFaultVec := VecInit(pds.zipWithIndex.map{case(pd, i) => pd.isJal && instrRange(i) && instrValid(i) && (takenIdx > i.U && predTaken || !predTaken) }) 345 retFaultVec := VecInit(pds.zipWithIndex.map{case(pd, i) => pd.isRet && instrRange(i) && instrValid(i) && (takenIdx > i.U && predTaken || !predTaken) }) 346 val remaskFault = VecInit((0 until PredictWidth).map(i => jalFaultVec(i) || retFaultVec(i))) 347 val remaskIdx = ParallelPriorityEncoder(remaskFault.asUInt) 348 val needRemask = ParallelOR(remaskFault) 349 val fixedRange = instrRange.asUInt & (Fill(PredictWidth, !needRemask) | Fill(PredictWidth, 1.U(1.W)) >> ~remaskIdx) 350 351 io.out.stage1Out.fixedRange := fixedRange.asTypeOf((Vec(PredictWidth, Bool()))) 352 353 io.out.stage1Out.fixedTaken := VecInit(pds.zipWithIndex.map{case(pd, i) => instrValid (i) && fixedRange(i) && (pd.isRet || pd.isJal || takenIdx === i.U && predTaken && !pd.notCFI) }) 354 355 /** second check: faulse prediction fault and target fault */ 356 notCFITaken := VecInit(pds.zipWithIndex.map{case(pd, i) => fixedRange(i) && instrValid(i) && i.U === takenIdx && pd.notCFI && predTaken }) 357 invalidTaken := VecInit(pds.zipWithIndex.map{case(pd, i) => fixedRange(i) && !instrValid(i) && i.U === takenIdx && predTaken }) 358 359 val jumpTargets = VecInit(pds.zipWithIndex.map{case(pd,i) => (pc(i) + jumpOffset(i)).asTypeOf(UInt(VAddrBits.W))}) 360 val seqTargets = VecInit((0 until PredictWidth).map(i => pc(i) + Mux(pds(i).isRVC || !instrValid(i), 2.U, 4.U ) )) 361 362 //Stage 2: detect target fault 363 /** target calculation: in the next stage */ 364 val fixedRangeNext = RegNext(fixedRange) 365 val instrValidNext = RegNext(instrValid) 366 val takenIdxNext = RegNext(takenIdx) 367 val predTakenNext = RegNext(predTaken) 368 val predTargetNext = RegNext(predTarget) 369 val jumpTargetsNext = RegNext(jumpTargets) 370 val seqTargetsNext = RegNext(seqTargets) 371 val pdsNext = RegNext(pds) 372 val jalFaultVecNext = RegNext(jalFaultVec) 373 val retFaultVecNext = RegNext(retFaultVec) 374 val notCFITakenNext = RegNext(notCFITaken) 375 val invalidTakenNext = RegNext(invalidTaken) 376 377 targetFault := VecInit(pdsNext.zipWithIndex.map{case(pd,i) => fixedRangeNext(i) && instrValidNext(i) && (pd.isJal || pd.isBr) && takenIdxNext === i.U && predTakenNext && (predTargetNext =/= jumpTargetsNext(i))}) 378 379 380 io.out.stage2Out.faultType.zipWithIndex.map{case(faultType, i) => faultType.value := Mux(jalFaultVecNext(i) , FaultType.jalFault , 381 Mux(retFaultVecNext(i), FaultType.retFault , 382 Mux(targetFault(i), FaultType.targetFault , 383 Mux(notCFITakenNext(i) , FaultType.notCFIFault, 384 Mux(invalidTakenNext(i), FaultType.invalidTaken, FaultType.noFault)))))} 385 386 io.out.stage2Out.fixedMissPred.zipWithIndex.map{case(missPred, i ) => missPred := jalFaultVecNext(i) || retFaultVecNext(i) || notCFITakenNext(i) || invalidTakenNext(i) || targetFault(i)} 387 io.out.stage2Out.fixedTarget.zipWithIndex.map{case(target, i) => target := Mux(jalFaultVecNext(i) || targetFault(i), jumpTargetsNext(i), seqTargetsNext(i) )} 388 io.out.stage2Out.jalTarget.zipWithIndex.map{case(target, i) => target := jumpTargetsNext(i) } 389 390} 391 392class FrontendTrigger(implicit p: Parameters) extends XSModule { 393 val io = IO(new Bundle(){ 394 val frontendTrigger = Input(new FrontendTdataDistributeIO) 395 val csrTriggerEnable = Input(Vec(4, Bool())) 396 val triggered = Output(Vec(PredictWidth, new TriggerCf)) 397 398 val pds = Input(Vec(PredictWidth, new PreDecodeInfo)) 399 val pc = Input(Vec(PredictWidth, UInt(VAddrBits.W))) 400 val data = if(HasCExtension) Input(Vec(PredictWidth + 1, UInt(16.W))) 401 else Input(Vec(PredictWidth, UInt(32.W))) 402 }) 403 404 val data = io.data 405 406 val rawInsts = if (HasCExtension) VecInit((0 until PredictWidth).map(i => Cat(data(i+1), data(i)))) 407 else VecInit((0 until PredictWidth).map(i => data(i))) 408 409 val tdata = RegInit(VecInit(Seq.fill(4)(0.U.asTypeOf(new MatchTriggerIO)))) 410 when(io.frontendTrigger.t.valid) { 411 tdata(io.frontendTrigger.t.bits.addr) := io.frontendTrigger.t.bits.tdata 412 } 413 io.triggered.map{i => i := 0.U.asTypeOf(new TriggerCf)} 414 val triggerEnable = RegInit(VecInit(Seq.fill(4)(false.B))) // From CSR, controlled by priv mode, etc. 415 triggerEnable := io.csrTriggerEnable 416 XSDebug(triggerEnable.asUInt.orR, "Debug Mode: At least one frontend trigger is enabled\n") 417 418 for (i <- 0 until 4) {PrintTriggerInfo(triggerEnable(i), tdata(i))} 419 val triggerHitVec = Wire(Vec(4, Vec(PredictWidth, Bool()))) 420 421 for (j <- 1 until 4) { 422 // port 0 support inst cmp while others don't 423 triggerHitVec(j) := TriggerCmpConsecutive(io.pc, tdata(j).tdata2, tdata(j).matchType, triggerEnable(j), VAddrBits) 424 } 425 426 for (i <- 0 until PredictWidth) { 427 val currentPC = io.pc(i) 428 val currentIsRVC = io.pds(i).isRVC 429 val inst = WireInit(rawInsts(i)) 430 val triggerHitVec_diff = Wire(Vec(4, Bool())) 431 432 for (j <- 0 until 1) { 433 triggerHitVec(j)(i) := TriggerCmp(Mux(tdata(j).select, Mux(currentIsRVC, inst(15, 0), inst), currentPC), 434 tdata(j).tdata2, tdata(j).matchType, triggerEnable(j)) 435 triggerHitVec_diff(j) := triggerHitVec(j)(i) 436 } 437 for (j <- 1 until 4) { 438 triggerHitVec_diff(j) := TriggerCmp(currentPC, tdata(j).tdata2, tdata(j).matchType, triggerEnable(j)) 439 } 440 441 for (j <- 0 until 4) { 442 XSError(triggerHitVec_diff(j) =/= triggerHitVec(j)(i), p"triggerHitVec_diff(${j}) mismatch\n") 443 } 444 445 val frontendHit = Wire(Vec(4, Bool())) 446 for (j <- 0 until 4) { 447 frontendHit(j) := triggerHitVec(j)(i) 448 } 449 450 // fix chains this could be moved further into the pipeline 451 io.triggered(i).frontendHit := frontendHit 452 val enableChain = tdata(0).chain 453 when(enableChain){ 454 io.triggered(i).frontendHit(0) := triggerHitVec(0)(i) && triggerHitVec(1)(i) && (tdata(0).timing === tdata(1).timing) 455 io.triggered(i).frontendHit(1) := triggerHitVec(0)(i) && triggerHitVec(1)(i) && (tdata(0).timing === tdata(1).timing) 456 } 457 for(j <- 0 until 2) { 458 io.triggered(i).backendEn(j) := Mux(tdata(j+2).chain, triggerHitVec(j+2)(i), true.B) 459 io.triggered(i).frontendHit(j+2) := !tdata(j+2).chain && triggerHitVec(j+2)(i) // temporary workaround 460 } 461 XSDebug(io.triggered(i).getHitFrontend, p"Debug Mode: Predecode Inst No. ${i} has trigger hit vec ${io.triggered(i).frontendHit}" + 462 p"and backend en ${io.triggered(i).backendEn}\n") 463 } 464} 465