From c4c66c7b6e4de43c35d4a61cd16c13fbef597cb8 Mon Sep 17 00:00:00 2001 From: Lucas-Wye Date: Sun, 26 May 2024 15:22:26 +0800 Subject: [PATCH] [doc] refactor and add all attributes --- t1/src/decoder/T1DecodePattern.scala | 112 ++- t1/src/decoder/attribute/isAdder.scala | 345 ++++++++++ t1/src/decoder/attribute/isAverage.scala | 345 ++++++++++ t1/src/decoder/attribute/isCompress.scala | 352 ++++++++++ t1/src/decoder/attribute/isCrossread.scala | 345 ++++++++++ t1/src/decoder/attribute/isCrosswrite.scala | 345 ++++++++++ t1/src/decoder/attribute/isDivider.scala | 345 ++++++++++ .../attribute/isDontneedexecuteinlane.scala | 345 ++++++++++ t1/src/decoder/attribute/isExtend.scala | 345 ++++++++++ t1/src/decoder/attribute/isFcompare.scala | 345 ++++++++++ t1/src/decoder/attribute/isFfo.scala | 345 ++++++++++ t1/src/decoder/attribute/isFirstwiden.scala | 345 ++++++++++ t1/src/decoder/attribute/isFloat.scala | 439 ++++++++++++ t1/src/decoder/attribute/isFloatmul.scala | 345 ++++++++++ t1/src/decoder/attribute/isFloattype.scala | 345 ++++++++++ t1/src/decoder/attribute/isFma.scala | 345 ++++++++++ t1/src/decoder/attribute/isFother.scala | 345 ++++++++++ t1/src/decoder/attribute/isGather.scala | 369 ++++++++++ t1/src/decoder/attribute/isGather16.scala | 345 ++++++++++ t1/src/decoder/attribute/isId.scala | 395 +++++++++++ t1/src/decoder/attribute/isIndextype.scala | 345 ++++++++++ t1/src/decoder/attribute/isIota.scala | 356 ++++++++++ t1/src/decoder/attribute/isItype.scala | 345 ++++++++++ t1/src/decoder/attribute/isLogic.scala | 345 ++++++++++ t1/src/decoder/attribute/isMa.scala | 641 ++++++++++++++++++ .../decoder/attribute/isMaskdestination.scala | 345 ++++++++++ t1/src/decoder/attribute/isMasklogic.scala | 345 ++++++++++ t1/src/decoder/attribute/isMasksource.scala | 345 ++++++++++ t1/src/decoder/attribute/isMaskunit.scala | 345 ++++++++++ t1/src/decoder/attribute/isMulticycle.scala | 345 ++++++++++ t1/src/decoder/attribute/isMultiplier.scala | 345 ++++++++++ t1/src/decoder/attribute/isMv.scala | 400 +++++++++++ t1/src/decoder/attribute/isNarrow.scala | 345 ++++++++++ t1/src/decoder/attribute/isNr.scala | 345 ++++++++++ t1/src/decoder/attribute/isOrderreduce.scala | 345 ++++++++++ t1/src/decoder/attribute/isOther.scala | 345 ++++++++++ t1/src/decoder/attribute/isPopcount.scala | 345 ++++++++++ t1/src/decoder/attribute/isReadonly.scala | 345 ++++++++++ t1/src/decoder/attribute/isRed.scala | 467 +++++++++++++ t1/src/decoder/attribute/isReverse.scala | 345 ++++++++++ t1/src/decoder/attribute/isSaturate.scala | 345 ++++++++++ t1/src/decoder/attribute/isScheduler.scala | 345 ++++++++++ t1/src/decoder/attribute/isShift.scala | 345 ++++++++++ t1/src/decoder/attribute/isSlid.scala | 389 +++++++++++ t1/src/decoder/attribute/isSpecial.scala | 391 +++++++++++ t1/src/decoder/attribute/isSpecialslot.scala | 345 ++++++++++ t1/src/decoder/attribute/isSreadvd.scala | 345 ++++++++++ t1/src/decoder/attribute/isSwrite.scala | 374 ++++++++++ t1/src/decoder/attribute/isTargetrd.scala | 345 ++++++++++ t1/src/decoder/attribute/isUnorderwrite.scala | 345 ++++++++++ t1/src/decoder/attribute/isUnsigned0.scala | 345 ++++++++++ t1/src/decoder/attribute/isUnsigned1_f.scala | 345 ++++++++++ t1/src/decoder/attribute/isUnsigned1_nf.scala | 345 ++++++++++ t1/src/decoder/attribute/isVtype.scala | 345 ++++++++++ t1/src/decoder/attribute/isVwmacc.scala | 411 +++++++++++ t1/src/decoder/attribute/isWidenreduce.scala | 345 ++++++++++ 56 files changed, 19930 insertions(+), 1 deletion(-) create mode 100644 t1/src/decoder/attribute/isAdder.scala create mode 100644 t1/src/decoder/attribute/isAverage.scala create mode 100644 t1/src/decoder/attribute/isCompress.scala create mode 100644 t1/src/decoder/attribute/isCrossread.scala create mode 100644 t1/src/decoder/attribute/isCrosswrite.scala create mode 100644 t1/src/decoder/attribute/isDivider.scala create mode 100644 t1/src/decoder/attribute/isDontneedexecuteinlane.scala create mode 100644 t1/src/decoder/attribute/isExtend.scala create mode 100644 t1/src/decoder/attribute/isFcompare.scala create mode 100644 t1/src/decoder/attribute/isFfo.scala create mode 100644 t1/src/decoder/attribute/isFirstwiden.scala create mode 100644 t1/src/decoder/attribute/isFloat.scala create mode 100644 t1/src/decoder/attribute/isFloatmul.scala create mode 100644 t1/src/decoder/attribute/isFloattype.scala create mode 100644 t1/src/decoder/attribute/isFma.scala create mode 100644 t1/src/decoder/attribute/isFother.scala create mode 100644 t1/src/decoder/attribute/isGather.scala create mode 100644 t1/src/decoder/attribute/isGather16.scala create mode 100644 t1/src/decoder/attribute/isId.scala create mode 100644 t1/src/decoder/attribute/isIndextype.scala create mode 100644 t1/src/decoder/attribute/isIota.scala create mode 100644 t1/src/decoder/attribute/isItype.scala create mode 100644 t1/src/decoder/attribute/isLogic.scala create mode 100644 t1/src/decoder/attribute/isMa.scala create mode 100644 t1/src/decoder/attribute/isMaskdestination.scala create mode 100644 t1/src/decoder/attribute/isMasklogic.scala create mode 100644 t1/src/decoder/attribute/isMasksource.scala create mode 100644 t1/src/decoder/attribute/isMaskunit.scala create mode 100644 t1/src/decoder/attribute/isMulticycle.scala create mode 100644 t1/src/decoder/attribute/isMultiplier.scala create mode 100644 t1/src/decoder/attribute/isMv.scala create mode 100644 t1/src/decoder/attribute/isNarrow.scala create mode 100644 t1/src/decoder/attribute/isNr.scala create mode 100644 t1/src/decoder/attribute/isOrderreduce.scala create mode 100644 t1/src/decoder/attribute/isOther.scala create mode 100644 t1/src/decoder/attribute/isPopcount.scala create mode 100644 t1/src/decoder/attribute/isReadonly.scala create mode 100644 t1/src/decoder/attribute/isRed.scala create mode 100644 t1/src/decoder/attribute/isReverse.scala create mode 100644 t1/src/decoder/attribute/isSaturate.scala create mode 100644 t1/src/decoder/attribute/isScheduler.scala create mode 100644 t1/src/decoder/attribute/isShift.scala create mode 100644 t1/src/decoder/attribute/isSlid.scala create mode 100644 t1/src/decoder/attribute/isSpecial.scala create mode 100644 t1/src/decoder/attribute/isSpecialslot.scala create mode 100644 t1/src/decoder/attribute/isSreadvd.scala create mode 100644 t1/src/decoder/attribute/isSwrite.scala create mode 100644 t1/src/decoder/attribute/isTargetrd.scala create mode 100644 t1/src/decoder/attribute/isUnorderwrite.scala create mode 100644 t1/src/decoder/attribute/isUnsigned0.scala create mode 100644 t1/src/decoder/attribute/isUnsigned1_f.scala create mode 100644 t1/src/decoder/attribute/isUnsigned1_nf.scala create mode 100644 t1/src/decoder/attribute/isVtype.scala create mode 100644 t1/src/decoder/attribute/isVwmacc.scala create mode 100644 t1/src/decoder/attribute/isWidenreduce.scala diff --git a/t1/src/decoder/T1DecodePattern.scala b/t1/src/decoder/T1DecodePattern.scala index 5552d0fe67..3332d0799d 100644 --- a/t1/src/decoder/T1DecodePattern.scala +++ b/t1/src/decoder/T1DecodePattern.scala @@ -11,7 +11,7 @@ import chisel3.util.BitPat import chisel3.util.experimental.decode.DecodePattern import org.chipsalliance.rvdecoderdb.Instruction import org.chipsalliance.t1.rtl.T1Parameter -import org.chipsalliance.t1.rtl.decoder.attribute.isVector +import org.chipsalliance.t1.rtl.decoder.attribute._ @instantiable class T1DecodeAttributeOM extends Class { @@ -57,6 +57,61 @@ case class T1DecodePattern(instruction: Instruction, t1Parameter: T1Parameter) e // use the attribute w/ [[isVector.value]] def isVector: isVector = attribute.isVector(this) + def isAdder: isAdder = attribute.isAdder(this) + def isAverage: isAverage = attribute.isAverage(this) + def isCompress: isCompress = attribute.isCompress(this) + def isCrossread: isCrossread = attribute.isCrossread(this) + def isCrosswrite: isCrosswrite = attribute.isCrosswrite(this) + def isDivider: isDivider = attribute.isDivider(this) + def isDontneedexecuteinlane: isDontneedexecuteinlane = attribute.isDontneedexecuteinlane(this) + def isExtend: isExtend = attribute.isExtend(this) + def isFcompare: isFcompare = attribute.isFcompare(this) + def isFfo: isFfo = attribute.isFfo(this) + def isFirstwiden: isFirstwiden = attribute.isFirstwiden(this) + def isFloatmul: isFloatmul = attribute.isFloatmul(this) + def isFloat: isFloat = attribute.isFloat(this) + def isFloattype: isFloattype = attribute.isFloattype(this) + def isFma: isFma = attribute.isFma(this) + def isFother: isFother = attribute.isFother(this) + def isGather16: isGather16 = attribute.isGather16(this) + def isGather: isGather = attribute.isGather(this) + def isId: isId = attribute.isId(this) + def isIndextype: isIndextype = attribute.isIndextype(this) + def isIota: isIota = attribute.isIota(this) + def isItype: isItype = attribute.isItype(this) + def isLogic: isLogic = attribute.isLogic(this) + def isMa: isMa = attribute.isMa(this) + def isMaskdestination: isMaskdestination = attribute.isMaskdestination(this) + def isMasklogic: isMasklogic = attribute.isMasklogic(this) + def isMasksource: isMasksource = attribute.isMasksource(this) + def isMaskunit: isMaskunit = attribute.isMaskunit(this) + def isMulticycle: isMulticycle = attribute.isMulticycle(this) + def isMultiplier: isMultiplier = attribute.isMultiplier(this) + def isMv: isMv = attribute.isMv(this) + def isNarrow: isNarrow = attribute.isNarrow(this) + def isNr: isNr = attribute.isNr(this) + def isOrderreduce: isOrderreduce = attribute.isOrderreduce(this) + def isOther: isOther = attribute.isOther(this) + def isPopcount: isPopcount = attribute.isPopcount(this) + def isReadonly: isReadonly = attribute.isReadonly(this) + def isRed: isRed = attribute.isRed(this) + def isReverse: isReverse = attribute.isReverse(this) + def isSaturate: isSaturate = attribute.isSaturate(this) + def isScheduler: isScheduler = attribute.isScheduler(this) + def isShift: isShift = attribute.isShift(this) + def isSlid: isSlid = attribute.isSlid(this) + def isSpecial: isSpecial = attribute.isSpecial(this) + def isSpecialslot: isSpecialslot = attribute.isSpecialslot(this) + def isSreadvd: isSreadvd = attribute.isSreadvd(this) + def isSwrite: isSwrite = attribute.isSwrite(this) + def isTargetrd: isTargetrd = attribute.isTargetrd(this) + def isUnorderwrite: isUnorderwrite = attribute.isUnorderwrite(this) + def isUnsigned0: isUnsigned0 = attribute.isUnsigned0(this) + def isUnsigned1_f: isUnsigned1_f = attribute.isUnsigned1_f(this) + def isUnsigned1_nf: isUnsigned1_nf = attribute.isUnsigned1_nf(this) + def isVtype: isVtype = attribute.isVtype(this) + def isVwmacc: isVwmacc = attribute.isVwmacc(this) + def isWidenreduce: isWidenreduce = attribute.isWidenreduce(this) private def documentation: String = InstructionDocumentation(instruction, t1Parameter).toString @@ -74,6 +129,61 @@ case class T1DecodePattern(instruction: Instruction, t1Parameter: T1Parameter) e obj.attributesIn :#= Property( Seq( isVector, + isAdder, + isAverage, + isCompress, + isCrossread, + isCrosswrite, + isDivider, + isDontneedexecuteinlane, + isExtend, + isFcompare, + isFfo, + isFirstwiden, + isFloatmul, + isFloat, + isFloattype, + isFma, + isFother, + isGather16, + isGather, + isId, + isIndextype, + isIota, + isItype, + isLogic, + isMa, + isMaskdestination, + isMasklogic, + isMasksource, + isMaskunit, + isMulticycle, + isMultiplier, + isMv, + isNarrow, + isNr, + isOrderreduce, + isOther, + isPopcount, + isReadonly, + isRed, + isReverse, + isSaturate, + isScheduler, + isShift, + isSlid, + isSpecial, + isSpecialslot, + isSreadvd, + isSwrite, + isTargetrd, + isUnorderwrite, + isUnsigned0, + isUnsigned1_f, + isUnsigned1_nf, + isVtype, + isVwmacc, + isWidenreduce, ).map(_.om.as(attributeClassTpe)) ) obj.getPropertyReference diff --git a/t1/src/decoder/attribute/isAdder.scala b/t1/src/decoder/attribute/isAdder.scala new file mode 100644 index 0000000000..624be4d6fa --- /dev/null +++ b/t1/src/decoder/attribute/isAdder.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isAdder { + def apply(t1DecodePattern: T1DecodePattern): isAdder = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isAdder(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isAdder(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "goes to [[org.chipsalliance.t1.rtl.LaneAdder]]." +} diff --git a/t1/src/decoder/attribute/isAverage.scala b/t1/src/decoder/attribute/isAverage.scala new file mode 100644 index 0000000000..d62af3d23e --- /dev/null +++ b/t1/src/decoder/attribute/isAverage.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isAverage { + def apply(t1DecodePattern: T1DecodePattern): isAverage = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isAverage(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isAverage(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "For adder, does it need to take care of saturate. TODO: add to uop " +} diff --git a/t1/src/decoder/attribute/isCompress.scala b/t1/src/decoder/attribute/isCompress.scala new file mode 100644 index 0000000000..342dc3aeee --- /dev/null +++ b/t1/src/decoder/attribute/isCompress.scala @@ -0,0 +1,352 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isCompress { + def apply(t1DecodePattern: T1DecodePattern): isCompress = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isCompress(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcompress.vm", + "vcompress.vm", + "vcompress.vm", + "vcompress.vm", + "vcompress.vm", + "vcompress.vm", + "vcompress.vm", + "vcompress.vm", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isCompress(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "lane will read data from vs2, send to Sequencer. then Sequencer will read vs1 for mask. use mask to compress data in vs2. and write to vd at last. " +} diff --git a/t1/src/decoder/attribute/isCrossread.scala b/t1/src/decoder/attribute/isCrossread.scala new file mode 100644 index 0000000000..ddf7fdda8d --- /dev/null +++ b/t1/src/decoder/attribute/isCrossread.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isCrossread { + def apply(t1DecodePattern: T1DecodePattern): isCrossread = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isCrossread(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfwadd.wf", + "vfwadd.wv", + "vfwsub.wf", + "vfwsub.wv", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.wv", + "vwsub.wx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwadd.vv", + "vwadd.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsub.vv", + "vwsub.vx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isCrossread(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "Read vs2 or vd with cross read channel. crossRead -> narrow || firstWiden " +} diff --git a/t1/src/decoder/attribute/isCrosswrite.scala b/t1/src/decoder/attribute/isCrosswrite.scala new file mode 100644 index 0000000000..dbacc6e11c --- /dev/null +++ b/t1/src/decoder/attribute/isCrosswrite.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isCrosswrite { + def apply(t1DecodePattern: T1DecodePattern): isCrosswrite = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isCrosswrite(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isCrosswrite(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "lane should write to another lane" +} diff --git a/t1/src/decoder/attribute/isDivider.scala b/t1/src/decoder/attribute/isDivider.scala new file mode 100644 index 0000000000..55f2fd6040 --- /dev/null +++ b/t1/src/decoder/attribute/isDivider.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isDivider { + def apply(t1DecodePattern: T1DecodePattern): isDivider = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isDivider(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isDivider(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "goes to [[org.chipsalliance.t1.rtl.LaneDiv]] or [[org.chipsalliance.t1.rtl.LaneDivFP]]. if FP exist, all div goes to [[org.chipsalliance.t1.rtl.LaneDivFP]]" +} diff --git a/t1/src/decoder/attribute/isDontneedexecuteinlane.scala b/t1/src/decoder/attribute/isDontneedexecuteinlane.scala new file mode 100644 index 0000000000..704b874d57 --- /dev/null +++ b/t1/src/decoder/attribute/isDontneedexecuteinlane.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isDontneedexecuteinlane { + def apply(t1DecodePattern: T1DecodePattern): isDontneedexecuteinlane = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isDontneedexecuteinlane(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "lsu", + "vcompress.vm", + "viota.m", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vrgatherei16.vv", + "vrgather.vv", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgather.vi", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isDontneedexecuteinlane(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "sExecute 与 wExecuteRes 也不一样,需要校验 sExecute -> readOnly || nr || loadStore Lane doesn't need VFU to execute the instruction. datapath will directly goes to VRF. " +} diff --git a/t1/src/decoder/attribute/isExtend.scala b/t1/src/decoder/attribute/isExtend.scala new file mode 100644 index 0000000000..2e04c214c4 --- /dev/null +++ b/t1/src/decoder/attribute/isExtend.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isExtend { + def apply(t1DecodePattern: T1DecodePattern): isExtend = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isExtend(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isExtend(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "send element to MaskUnit at top, extend and broadcast to multiple Lanes." +} diff --git a/t1/src/decoder/attribute/isFcompare.scala b/t1/src/decoder/attribute/isFcompare.scala new file mode 100644 index 0000000000..64f911f188 --- /dev/null +++ b/t1/src/decoder/attribute/isFcompare.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFcompare { + def apply(t1DecodePattern: T1DecodePattern): isFcompare = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFcompare(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfredmax.vs", + "vfredmin.vs", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFcompare(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "TODO: remove it, but remains attribute." +} diff --git a/t1/src/decoder/attribute/isFfo.scala b/t1/src/decoder/attribute/isFfo.scala new file mode 100644 index 0000000000..5c73fa96ff --- /dev/null +++ b/t1/src/decoder/attribute/isFfo.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFfo { + def apply(t1DecodePattern: T1DecodePattern): isFfo = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFfo(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfirst.m", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFfo(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "find first one, lane will report if 1 is found, Sequencer should decide which is exactly the first 1 in lanes. after 1 is found, tell each lane, 1 has been found at which the corresponding location. lane will stale at stage2. TODO: should split into lane control uop " +} diff --git a/t1/src/decoder/attribute/isFirstwiden.scala b/t1/src/decoder/attribute/isFirstwiden.scala new file mode 100644 index 0000000000..b3639eda8d --- /dev/null +++ b/t1/src/decoder/attribute/isFirstwiden.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFirstwiden { + def apply(t1DecodePattern: T1DecodePattern): isFirstwiden = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFirstwiden(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfwadd.wf", + "vfwadd.wv", + "vfwsub.wf", + "vfwsub.wv", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wv", + "vnclip.wx", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wv", + "vnsrl.wx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.wv", + "vwsub.wx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwadd.vv", + "vwadd.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsub.vv", + "vwsub.vx", + "vnsra.wi", + "vnsrl.wi", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclip.wi", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFirstwiden(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "There are two types of widen: - vd -> widen. - vs2, vd -> widen. This op will widen vs2. TODO: remove it as attribute." +} diff --git a/t1/src/decoder/attribute/isFloat.scala b/t1/src/decoder/attribute/isFloat.scala new file mode 100644 index 0000000000..fdb6ea97f2 --- /dev/null +++ b/t1/src/decoder/attribute/isFloat.scala @@ -0,0 +1,439 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFloat { + def apply(t1DecodePattern: T1DecodePattern): isFloat = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFloat(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfmul.vf", + "vfmul.vv", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfdiv.vf", + "vfdiv.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmerge.vfm", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfmv.s.f", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrdiv.vf", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfslide1down.vf", + "vfslide1up.vf", + "vfsqrt.v", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vcpop.m", + "vfirst.m", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFloat(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "goes to [[org.chipsalliance.t1.rtl.LaneFloat]]." +} diff --git a/t1/src/decoder/attribute/isFloatmul.scala b/t1/src/decoder/attribute/isFloatmul.scala new file mode 100644 index 0000000000..5993dcf4a0 --- /dev/null +++ b/t1/src/decoder/attribute/isFloatmul.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFloatmul { + def apply(t1DecodePattern: T1DecodePattern): isFloatmul = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFloatmul(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfmul.vf", + "vfmul.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFloatmul(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "TODO: add op." +} diff --git a/t1/src/decoder/attribute/isFloattype.scala b/t1/src/decoder/attribute/isFloattype.scala new file mode 100644 index 0000000000..073d9656ad --- /dev/null +++ b/t1/src/decoder/attribute/isFloattype.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFloattype { + def apply(t1DecodePattern: T1DecodePattern): isFloattype = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFloattype(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfdiv.vf", + "vfdiv.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmerge.vfm", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfmv.s.f", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrdiv.vf", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfslide1down.vf", + "vfslide1up.vf", + "vfsqrt.v", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vcpop.m", + "vfirst.m", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFloattype(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "is a float type. TODO: remove it." +} diff --git a/t1/src/decoder/attribute/isFma.scala b/t1/src/decoder/attribute/isFma.scala new file mode 100644 index 0000000000..aec0285dd8 --- /dev/null +++ b/t1/src/decoder/attribute/isFma.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFma { + def apply(t1DecodePattern: T1DecodePattern): isFma = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFma(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfadd.vf", + "vfadd.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfredosum.vs", + "vfredusum.vs", + "vfrsub.vf", + "vfsub.vf", + "vfsub.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfrsqrt7.v", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFma(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "uop of FMA, goes to [[org.chipsalliance.t1.rtl.LaneFloat]] FMA unit." +} diff --git a/t1/src/decoder/attribute/isFother.scala b/t1/src/decoder/attribute/isFother.scala new file mode 100644 index 0000000000..4b3b8f3ced --- /dev/null +++ b/t1/src/decoder/attribute/isFother.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isFother { + def apply(t1DecodePattern: T1DecodePattern): isFother = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isFother(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfrec7.v", + "vfrsqrt7.v", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsub.vf", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isFother(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "designed for Other Unit in FP. goes to [[org.chipsalliance.t1.rtl.LaneFloat]] OtherUnit. TODO: perf it." +} diff --git a/t1/src/decoder/attribute/isGather.scala b/t1/src/decoder/attribute/isGather.scala new file mode 100644 index 0000000000..80bee41346 --- /dev/null +++ b/t1/src/decoder/attribute/isGather.scala @@ -0,0 +1,369 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isGather { + def apply(t1DecodePattern: T1DecodePattern): isGather = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isGather(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vrgatherei16.vv", + "vrgather.vv", + "vrgatherei16.vv", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vrgather.vi", + "vrgatherei16.vv", + "vrgather.vv", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vrgatherei16.vv", + "vrgather.vv", + "vrgather.vi", + "vrgather.vx", + "vrgatherei16.vv", + "vrgather.vv", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vrgatherei16.vv", + "vrgather.vv", + "vrgatherei16.vv", + "vrgather.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isGather(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "lane will read index from vs1, send to Sequencer. mask unit will calculate vrf address based on the vs1 from lane, and send read request to lanes, lanes should read it and send vs2 to Sequencer. Sequencer will write vd at last. address: 0 -> vlmax(sew decide address width.) " +} diff --git a/t1/src/decoder/attribute/isGather16.scala b/t1/src/decoder/attribute/isGather16.scala new file mode 100644 index 0000000000..e0e1dc146b --- /dev/null +++ b/t1/src/decoder/attribute/isGather16.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isGather16 { + def apply(t1DecodePattern: T1DecodePattern): isGather16 = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isGather16(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vrgatherei16.vv", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isGather16(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "same with [[gather]] ignore sew, address width is fixed to 16. @note When SEW=8, vrgather.vv can only reference vector elements 0-255. The vrgatherei16 form can index 64K elements, and can also be used to reduce the register capacity needed to hold indices when SEW > 16. " +} diff --git a/t1/src/decoder/attribute/isId.scala b/t1/src/decoder/attribute/isId.scala new file mode 100644 index 0000000000..535f32541e --- /dev/null +++ b/t1/src/decoder/attribute/isId.scala @@ -0,0 +1,395 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isId { + def apply(t1DecodePattern: T1DecodePattern): isId = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isId(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfwadd.wf", + "vfwadd.wv", + "vfwsub.wf", + "vfwsub.wv", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wv", + "vnclip.wx", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wv", + "vnsrl.wx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.wv", + "vwsub.wx", + "vfslide1down.vf", + "vfslide1up.vf", + "vid.v", + "vslidedown.vi", + "vslideup.vi", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vid.v", + "vfslide1down.vf", + "vfslide1up.vf", + "vid.v", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vid.v", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vid.v", + "vid.v", + "vid.v", + "vwredsumu.vs", + "vwredsum.vs", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwadd.vv", + "vwadd.vx", + "vwsubu.vv", + "vwsubu.vx", + "vwsub.vv", + "vwsub.vx", + "vnsra.wi", + "vnsrl.wi", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclip.wi", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isId(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "write 0...vlmax to VRF. Lane other unit should handle it. TODO: remove it, it's a uop. " +} diff --git a/t1/src/decoder/attribute/isIndextype.scala b/t1/src/decoder/attribute/isIndextype.scala new file mode 100644 index 0000000000..a07a2882ba --- /dev/null +++ b/t1/src/decoder/attribute/isIndextype.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isIndextype { + def apply(t1DecodePattern: T1DecodePattern): isIndextype = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isIndextype(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isIndextype(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "TODO: remove it." +} diff --git a/t1/src/decoder/attribute/isIota.scala b/t1/src/decoder/attribute/isIota.scala new file mode 100644 index 0000000000..9206f326a6 --- /dev/null +++ b/t1/src/decoder/attribute/isIota.scala @@ -0,0 +1,356 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isIota { + def apply(t1DecodePattern: T1DecodePattern): isIota = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isIota(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + "viota.m", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isIota(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "lane will read vs2 from VRF, send to Top. Top read v0(at register) calculate the result and write back to VRFs " +} diff --git a/t1/src/decoder/attribute/isItype.scala b/t1/src/decoder/attribute/isItype.scala new file mode 100644 index 0000000000..63546433c6 --- /dev/null +++ b/t1/src/decoder/attribute/isItype.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isItype { + def apply(t1DecodePattern: T1DecodePattern): isItype = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isItype(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vadc.vim", + "vadd.vi", + "vand.vi", + "vmadc.vi", + "vmadc.vim", + "vmerge.vim", + "vmseq.vi", + "vmsgtu.vi", + "vmsgt.vi", + "vmsleu.vi", + "vmsle.vi", + "vmsne.vi", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vnclipu.wi", + "vnclip.wi", + "vnsra.wi", + "vnsrl.wi", + "vor.vi", + "vrgather.vi", + "vrsub.vi", + "vsaddu.vi", + "vsadd.vi", + "vslidedown.vi", + "vslideup.vi", + "vsll.vi", + "vsra.vi", + "vsrl.vi", + "vssra.vi", + "vssrl.vi", + "vxor.vi", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vvm", + "vadc.vxm", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vx", + "vmsgt.vx", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vx", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vv", + "vsll.vx", + "vsra.vv", + "vsra.vx", + "vsrl.vv", + "vsrl.vx", + "vssra.vv", + "vssra.vx", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isItype(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "src is imm." +} diff --git a/t1/src/decoder/attribute/isLogic.scala b/t1/src/decoder/attribute/isLogic.scala new file mode 100644 index 0000000000..1dea37a22a --- /dev/null +++ b/t1/src/decoder/attribute/isLogic.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isLogic { + def apply(t1DecodePattern: T1DecodePattern): isLogic = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isLogic(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isLogic(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "Instruction should use [[org.chipsalliance.t1.rtl.decoder.TableGenerator.LaneDecodeTable.LogicUnit]]." +} diff --git a/t1/src/decoder/attribute/isMa.scala b/t1/src/decoder/attribute/isMa.scala new file mode 100644 index 0000000000..cf16ebc855 --- /dev/null +++ b/t1/src/decoder/attribute/isMa.scala @@ -0,0 +1,641 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMa { + def apply(t1DecodePattern: T1DecodePattern): isMa = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMa(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vredmaxu.vs", + "vredmax.vs", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vfmax.vf", + "vfmax.vv", + "vfredmax.vs", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfredmax.vs", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfredmax.vs", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vmadc.vi", + "vmadc.vim", + "vmand.mm", + "vmandn.mm", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vcpop.m", + "vfirst.m", + "viota.m", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmxnor.mm", + "vmxor.mm", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vfmerge.vfm", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vsbc.vvm", + "vsbc.vxm", + "vcompress.vm", + "vcpop.m", + "vfirst.m", + "vfmv.f.s", + "vfmv.s.f", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfslide1down.vf", + "vfslide1up.vf", + "vfwredosum.vs", + "vfwredusum.vs", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vrgatherei16.vv", + "vrgather.vv", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfredmax.vs", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vfredmax.vs", + "vredmaxu.vs", + "vredmax.vs", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmand.mm", + "vmandn.mm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmand.mm", + "vmandn.mm", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vfredmax.vs", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vredmaxu.vs", + "vredmax.vs", + "vfmax.vf", + "vfmax.vv", + "vfredmax.vs", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vredmaxu.vs", + "vredmax.vs", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vfredmax.vs", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vredmaxu.vs", + "vredmax.vs", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vredmaxu.vs", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vredmaxu.vs", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vfmacc.vv", + "vfmadd.vv", + "vfmax.vv", + "vfnmacc.vv", + "vfnmadd.vv", + "vfredmax.vs", + "vfwmacc.vv", + "vfwnmacc.vv", + "vmacc.vv", + "vmadc.vv", + "vmadc.vvm", + "vmadd.vv", + "vmand.mm", + "vmandn.mm", + "vmaxu.vv", + "vmax.vv", + "vredmaxu.vs", + "vredmax.vs", + "vwmaccsu.vv", + "vwmaccu.vv", + "vwmacc.vv", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vor.vi", + "vor.vv", + "vor.vx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vsmul.vv", + "vsmul.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmin.vf", + "vfmin.vv", + "vfmul.vf", + "vfmul.vv", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfrec7.v", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vid.v", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgather.vi", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMa(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "decodeResult(Decoder.multiplier) && decodeResult(Decoder.uop)(1, 0).xorR && !decodeResult(Decoder.vwmacc) TODO: remove it. */ " +} diff --git a/t1/src/decoder/attribute/isMaskdestination.scala b/t1/src/decoder/attribute/isMaskdestination.scala new file mode 100644 index 0000000000..6266466e4f --- /dev/null +++ b/t1/src/decoder/attribute/isMaskdestination.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMaskdestination { + def apply(t1DecodePattern: T1DecodePattern): isMaskdestination = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMaskdestination(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMaskdestination(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "vd is mask format. execute at lane, send result to Sequencer, regroup it and write to vd. if datapath is unaligned, need to take care the tail. " +} diff --git a/t1/src/decoder/attribute/isMasklogic.scala b/t1/src/decoder/attribute/isMasklogic.scala new file mode 100644 index 0000000000..5cb9cdc7e4 --- /dev/null +++ b/t1/src/decoder/attribute/isMasklogic.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMasklogic { + def apply(t1DecodePattern: T1DecodePattern): isMasklogic = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMasklogic(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcpop.m", + "vfirst.m", + "viota.m", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmxnor.mm", + "vmxor.mm", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMasklogic(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "only one or two operators src is mask format(one element one bit). vl should align with src. if datapath is unaligned, need to take care the tail. " +} diff --git a/t1/src/decoder/attribute/isMasksource.scala b/t1/src/decoder/attribute/isMasksource.scala new file mode 100644 index 0000000000..4ff2cbde96 --- /dev/null +++ b/t1/src/decoder/attribute/isMasksource.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMasksource { + def apply(t1DecodePattern: T1DecodePattern): isMasksource = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMasksource(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vfmerge.vfm", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vsbc.vvm", + "vsbc.vxm", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmv.s.f", + "vid.v", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMasksource(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "three ops. these ops don't use mask. use v0 as third op, read it from duplicate V0. it will read use mask(v0) in mask format as source. " +} diff --git a/t1/src/decoder/attribute/isMaskunit.scala b/t1/src/decoder/attribute/isMaskunit.scala new file mode 100644 index 0000000000..3e33dd7114 --- /dev/null +++ b/t1/src/decoder/attribute/isMaskunit.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMaskunit { + def apply(t1DecodePattern: T1DecodePattern): isMaskunit = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMaskunit(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcompress.vm", + "vcpop.m", + "vfirst.m", + "vfmv.f.s", + "vfmv.s.f", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfslide1down.vf", + "vfslide1up.vf", + "vfwredosum.vs", + "vfwredusum.vs", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vrgatherei16.vv", + "vrgather.vv", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vfmerge.vfm", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgather.vi", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMaskunit(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "mask unit -> red || compress || viota || ffo || slid || maskDestination || gather(v) || mv || popCount || extend all instruction in Sequencer mask unit. " +} diff --git a/t1/src/decoder/attribute/isMulticycle.scala b/t1/src/decoder/attribute/isMulticycle.scala new file mode 100644 index 0000000000..c6c618c028 --- /dev/null +++ b/t1/src/decoder/attribute/isMulticycle.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMulticycle { + def apply(t1DecodePattern: T1DecodePattern): isMulticycle = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMulticycle(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfdiv.vf", + "vfdiv.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrdiv.vf", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsqrt.v", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMulticycle(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "TODO: remove? only Div or customer" +} diff --git a/t1/src/decoder/attribute/isMultiplier.scala b/t1/src/decoder/attribute/isMultiplier.scala new file mode 100644 index 0000000000..60aa1d9396 --- /dev/null +++ b/t1/src/decoder/attribute/isMultiplier.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMultiplier { + def apply(t1DecodePattern: T1DecodePattern): isMultiplier = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMultiplier(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMultiplier(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "goes to [[org.chipsalliance.t1.rtl.LaneMul]]. (only apply to int mul)" +} diff --git a/t1/src/decoder/attribute/isMv.scala b/t1/src/decoder/attribute/isMv.scala new file mode 100644 index 0000000000..d11d6127d5 --- /dev/null +++ b/t1/src/decoder/attribute/isMv.scala @@ -0,0 +1,400 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isMv { + def apply(t1DecodePattern: T1DecodePattern): isMv = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isMv(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vfmv.f.s", + "vfmv.s.f", + "vfmv.f.s", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vfmv.f.s", + "vfmv.s.f", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vfmv.f.s", + "vfmv.s.f", + "vmv.s.x", + "vmv.x.s", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vfmv.s.f", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vfmv.s.f", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vfmv.s.f", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vfmv.s.f", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vmv.x.s", + "vfmv.f.s", + "vmv.x.s", + "vfmv.f.s", + "vfmv.s.f", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vfmv.s.f", + "vmv.s.x", + "vmv.x.s", + "vmv.s.x", + "vmv.x.s", + "vfmv.f.s", + "vmv.x.s", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isMv(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "move instruction, v->v s->v x->v, single element move. TODO: split them into multiple op since datapath differs " +} diff --git a/t1/src/decoder/attribute/isNarrow.scala b/t1/src/decoder/attribute/isNarrow.scala new file mode 100644 index 0000000000..02412dbb21 --- /dev/null +++ b/t1/src/decoder/attribute/isNarrow.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isNarrow { + def apply(t1DecodePattern: T1DecodePattern): isNarrow = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isNarrow(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isNarrow(value: TriState) extends BooleanDecodeAttribute { + override val description: String = " dual width of src will be convert to single width to dst. narrow can be the src of chain. as the dst of chain, only can be fed with Load. TODO: remove it as attribute. " +} diff --git a/t1/src/decoder/attribute/isNr.scala b/t1/src/decoder/attribute/isNr.scala new file mode 100644 index 0000000000..66d2ec4c50 --- /dev/null +++ b/t1/src/decoder/attribute/isNr.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isNr { + def apply(t1DecodePattern: T1DecodePattern): isNr = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isNr(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isNr(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "for vmvnr, move vreg group to another vreg group. it will ignore lmul, use from instr. chainable" +} diff --git a/t1/src/decoder/attribute/isOrderreduce.scala b/t1/src/decoder/attribute/isOrderreduce.scala new file mode 100644 index 0000000000..5036033d97 --- /dev/null +++ b/t1/src/decoder/attribute/isOrderreduce.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isOrderreduce { + def apply(t1DecodePattern: T1DecodePattern): isOrderreduce = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isOrderreduce(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfredosum.vs", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isOrderreduce(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "don't use it, it's slow, lane read all elements from VRF, send to Top." +} diff --git a/t1/src/decoder/attribute/isOther.scala b/t1/src/decoder/attribute/isOther.scala new file mode 100644 index 0000000000..371aee6e6d --- /dev/null +++ b/t1/src/decoder/attribute/isOther.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isOther { + def apply(t1DecodePattern: T1DecodePattern): isOther = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isOther(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isOther(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "goes to [[org.chipsalliance.t1.rtl.OtherUnit]]" +} diff --git a/t1/src/decoder/attribute/isPopcount.scala b/t1/src/decoder/attribute/isPopcount.scala new file mode 100644 index 0000000000..252d1b8c0c --- /dev/null +++ b/t1/src/decoder/attribute/isPopcount.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isPopcount { + def apply(t1DecodePattern: T1DecodePattern): isPopcount = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isPopcount(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcpop.m", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isPopcount(value: TriState) extends BooleanDecodeAttribute { + override val description: String = " count how many 1s in VS2. lane will use [[org.chipsalliance.t1.rtl.OtherUnit]] to how many 1s locally; use reduce datapath to accumulate, send total result to top top will send result to vd. " +} diff --git a/t1/src/decoder/attribute/isReadonly.scala b/t1/src/decoder/attribute/isReadonly.scala new file mode 100644 index 0000000000..6614ee2025 --- /dev/null +++ b/t1/src/decoder/attribute/isReadonly.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isReadonly { + def apply(t1DecodePattern: T1DecodePattern): isReadonly = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isReadonly(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcompress.vm", + "viota.m", + "vrgatherei16.vv", + "vrgather.vv", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgather.vi", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isReadonly(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "lane read only instructions. for these instructions lane will only read vrf and send data back to Sequencer. " +} diff --git a/t1/src/decoder/attribute/isRed.scala b/t1/src/decoder/attribute/isRed.scala new file mode 100644 index 0000000000..b1c028eb07 --- /dev/null +++ b/t1/src/decoder/attribute/isRed.scala @@ -0,0 +1,467 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isRed { + def apply(t1DecodePattern: T1DecodePattern): isRed = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isRed(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vfredosum.vs", + "vfredusum.vs", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vfredosum.vs", + "vcpop.m", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredosum.vs", + "vredmaxu.vs", + "vredminu.vs", + "vwredsumu.vs", + "vredmaxu.vs", + "vredminu.vs", + "vwredsumu.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vwredsumu.vs", + "vwredsum.vs", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isRed(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "do reduce in each lane. each element will sequentially executed in each lanes. after finishing, pop it to Top, and use ALU at top to get the final result and send to element0 TODO: better name. " +} diff --git a/t1/src/decoder/attribute/isReverse.scala b/t1/src/decoder/attribute/isReverse.scala new file mode 100644 index 0000000000..0b1e5f4f09 --- /dev/null +++ b/t1/src/decoder/attribute/isReverse.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isReverse { + def apply(t1DecodePattern: T1DecodePattern): isReverse = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isReverse(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vrsub.vi", + "vrsub.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isReverse(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "only instruction will switch src. TODO: send it to uop. " +} diff --git a/t1/src/decoder/attribute/isSaturate.scala b/t1/src/decoder/attribute/isSaturate.scala new file mode 100644 index 0000000000..fb292a02dd --- /dev/null +++ b/t1/src/decoder/attribute/isSaturate.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isSaturate { + def apply(t1DecodePattern: T1DecodePattern): isSaturate = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isSaturate(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsmul.vv", + "vsmul.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsbc.vvm", + "vsbc.vxm", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isSaturate(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "For adder, does it need to take care of saturate. TODO: add to uop " +} diff --git a/t1/src/decoder/attribute/isScheduler.scala b/t1/src/decoder/attribute/isScheduler.scala new file mode 100644 index 0000000000..2a17a5aa59 --- /dev/null +++ b/t1/src/decoder/attribute/isScheduler.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isScheduler { + def apply(t1DecodePattern: T1DecodePattern): isScheduler = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isScheduler(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vand.vi", + "vand.vv", + "vand.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfdiv.vf", + "vfdiv.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmerge.vfm", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfmv.s.f", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrdiv.vf", + "vfrec7.v", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfslide1down.vf", + "vfslide1up.vf", + "vfsqrt.v", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vid.v", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmand.mm", + "vmandn.mm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vmv.s.x", + "vmv.x.s", + "vmxnor.mm", + "vmxor.mm", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vor.vi", + "vor.vv", + "vor.vx", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vrgather.vi", + "vrgather.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsmul.vv", + "vsmul.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vwredsumu.vs", + "vwredsum.vs", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vrgatherei16.vv", + "vrgather.vv", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isScheduler(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "wScheduler 原来与 sScheduler 如果出错了需要检查一下,真不一样需要说明记录 sScheduler -> maskDestination || red || readOnly || ffo || popCount || loadStore lane will send request to Sequencer and wait ack from Sequencer. */ " +} diff --git a/t1/src/decoder/attribute/isShift.scala b/t1/src/decoder/attribute/isShift.scala new file mode 100644 index 0000000000..c50097ad8e --- /dev/null +++ b/t1/src/decoder/attribute/isShift.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isShift { + def apply(t1DecodePattern: T1DecodePattern): isShift = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isShift(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isShift(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "goes to [[org.chipsalliance.t1.rtl.LaneShifter]]." +} diff --git a/t1/src/decoder/attribute/isSlid.scala b/t1/src/decoder/attribute/isSlid.scala new file mode 100644 index 0000000000..59ebf042ae --- /dev/null +++ b/t1/src/decoder/attribute/isSlid.scala @@ -0,0 +1,389 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isSlid { + def apply(t1DecodePattern: T1DecodePattern): isSlid = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isSlid(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfslide1down.vf", + "vfslide1up.vf", + "vslidedown.vi", + "vslideup.vi", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isSlid(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "used in Sequencer mask unit, decide which vrf should be read. send read request to corresponding lane, lane will respond data to Sequencer. Sequencer will write data to VD. mask unit is work as the router here. TODO: opimize mask unit. " +} diff --git a/t1/src/decoder/attribute/isSpecial.scala b/t1/src/decoder/attribute/isSpecial.scala new file mode 100644 index 0000000000..9cf8f9596a --- /dev/null +++ b/t1/src/decoder/attribute/isSpecial.scala @@ -0,0 +1,391 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isSpecial { + def apply(t1DecodePattern: T1DecodePattern): isSpecial = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isSpecial(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "lsu", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfwadd.wf", + "vfwadd.wv", + "vfwsub.wf", + "vfwsub.wv", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmand.mm", + "vmandn.mm", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmsof.m", + "vmxnor.mm", + "vmxor.mm", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsbc.vvm", + "vsbc.vxm", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vcompress.vm", + "vcpop.m", + "vfirst.m", + "vfmv.f.s", + "vfmv.s.f", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfslide1down.vf", + "vfslide1up.vf", + "vfwredosum.vs", + "vfwredusum.vs", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vrgatherei16.vv", + "vrgather.vv", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vor.vi", + "vor.vv", + "vor.vx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwsub.vf", + "vfwsub.vv", + "vid.v", + "vrgather.vi", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isSpecial(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "if Sequencer is the router for data from Lane to LSU or Sequencer mask unit. special -> maskUnit || index type load store " +} diff --git a/t1/src/decoder/attribute/isSpecialslot.scala b/t1/src/decoder/attribute/isSpecialslot.scala new file mode 100644 index 0000000000..6777fa670f --- /dev/null +++ b/t1/src/decoder/attribute/isSpecialslot.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isSpecialslot { + def apply(t1DecodePattern: T1DecodePattern): isSpecialslot = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isSpecialslot(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfwadd.wf", + "vfwadd.wv", + "vfwsub.wf", + "vfwsub.wv", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmand.mm", + "vmandn.mm", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmsof.m", + "vmxnor.mm", + "vmxor.mm", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsbc.vvm", + "vsbc.vxm", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfmv.s.f", + "vid.v", + "vmv.s.x", + "vmv.x.s", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isSpecialslot(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "lane中只能在slot0中执行的指令 specialSlot -> crossRead || crossWrite || maskLogic || maskDestination || maskSource instructions schedule to slot0. " +} diff --git a/t1/src/decoder/attribute/isSreadvd.scala b/t1/src/decoder/attribute/isSreadvd.scala new file mode 100644 index 0000000000..9cd6976258 --- /dev/null +++ b/t1/src/decoder/attribute/isSreadvd.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isSreadvd { + def apply(t1DecodePattern: T1DecodePattern): isSreadvd = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isSreadvd(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "lsu", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vand.vi", + "vand.vv", + "vand.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vcompress.vm", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfdiv.vf", + "vfdiv.vv", + "vfmax.vf", + "vfmax.vv", + "vfmerge.vfm", + "vfmin.vf", + "vfmin.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfmv.s.f", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfrdiv.vf", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfslide1down.vf", + "vfslide1up.vf", + "vfsqrt.v", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vid.v", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsmul.vv", + "vsmul.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vcpop.m", + "vfirst.m", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "viota.m", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isSreadvd(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "sReadVD -> !(ma || maskLogic) instruction need to read vd as operator. " +} diff --git a/t1/src/decoder/attribute/isSwrite.scala b/t1/src/decoder/attribute/isSwrite.scala new file mode 100644 index 0000000000..2e74af7b1a --- /dev/null +++ b/t1/src/decoder/attribute/isSwrite.scala @@ -0,0 +1,374 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isSwrite { + def apply(t1DecodePattern: T1DecodePattern): isSwrite = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isSwrite(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "lsu", + "vcompress.vm", + "vcpop.m", + "vfirst.m", + "vfmv.f.s", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfwredosum.vs", + "vfwredusum.vs", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vmv.x.s", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vrgatherei16.vv", + "vrgather.vv", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgather.vi", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isSwrite(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "sWrite -> targetRd || readOnly || crossWrite || maskDestination || reduce || loadStore instruction will write vd or rd(scalar) from outside of lane. It will request vrf wait, and lane will not write. " +} diff --git a/t1/src/decoder/attribute/isTargetrd.scala b/t1/src/decoder/attribute/isTargetrd.scala new file mode 100644 index 0000000000..5556576126 --- /dev/null +++ b/t1/src/decoder/attribute/isTargetrd.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isTargetrd { + def apply(t1DecodePattern: T1DecodePattern): isTargetrd = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isTargetrd(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vcpop.m", + "vfirst.m", + "vfmv.f.s", + "vmv.x.s", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isTargetrd(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "write rd/fd at scalar core." +} diff --git a/t1/src/decoder/attribute/isUnorderwrite.scala b/t1/src/decoder/attribute/isUnorderwrite.scala new file mode 100644 index 0000000000..30cf0e302d --- /dev/null +++ b/t1/src/decoder/attribute/isUnorderwrite.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isUnorderwrite { + def apply(t1DecodePattern: T1DecodePattern): isUnorderwrite = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isUnorderwrite(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfmv.f.s", + "vfmv.s.f", + "vfredosum.vs", + "vfslide1down.vf", + "vfslide1up.vf", + "viota.m", + "vmv.s.x", + "vmv.x.s", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vi", + "vslidedown.vx", + "vslideup.vi", + "vslideup.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isUnorderwrite(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "unmanaged write for VRF. these instructions cannot be chain as source. TODO: add an attribute these instruction cannot be the source of chaining. " +} diff --git a/t1/src/decoder/attribute/isUnsigned0.scala b/t1/src/decoder/attribute/isUnsigned0.scala new file mode 100644 index 0000000000..79fe4fcf00 --- /dev/null +++ b/t1/src/decoder/attribute/isUnsigned0.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isUnsigned0 { + def apply(t1DecodePattern: T1DecodePattern): isUnsigned0 = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isUnsigned0(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaaddu.vx", + "vasubu.vv", + "vasubu.vx", + "vcpop.m", + "vdivu.vv", + "vdivu.vx", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfirst.m", + "vfmv.f.s", + "vfmv.s.f", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfrec7.v", + "vfrsqrt7.v", + "vfsqrt.v", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vid.v", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vminu.vv", + "vminu.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmsof.m", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vredmaxu.vs", + "vredminu.vs", + "vremu.vv", + "vremu.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vssubu.vv", + "vssubu.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwredsumu.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasub.vv", + "vasub.vx", + "vmax.vv", + "vmax.vx", + "vmin.vv", + "vmin.vx", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmax.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsum.vs", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmul.vv", + "vwmul.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfmerge.vfm", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isUnsigned0(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "is src0 unsigned? used everywhere in Lane and VFU. " +} diff --git a/t1/src/decoder/attribute/isUnsigned1_f.scala b/t1/src/decoder/attribute/isUnsigned1_f.scala new file mode 100644 index 0000000000..779419e71d --- /dev/null +++ b/t1/src/decoder/attribute/isUnsigned1_f.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isUnsigned1_f { + def apply(t1DecodePattern: T1DecodePattern): isUnsigned1_f = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isUnsigned1_f(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vfcvt.f.xu.v", + "vfcvt.rtz.xu.f.v", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isUnsigned1_f(value: TriState) extends BooleanDecodeAttribute { + override val description: String = " is src1 unsigned? used everywhere in Lane and VFU. " +} diff --git a/t1/src/decoder/attribute/isUnsigned1_nf.scala b/t1/src/decoder/attribute/isUnsigned1_nf.scala new file mode 100644 index 0000000000..8995b81433 --- /dev/null +++ b/t1/src/decoder/attribute/isUnsigned1_nf.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isUnsigned1_nf { + def apply(t1DecodePattern: T1DecodePattern): isUnsigned1_nf = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isUnsigned1_nf(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaaddu.vx", + "vasubu.vv", + "vasubu.vx", + "vcpop.m", + "vdivu.vv", + "vdivu.vx", + "vfirst.m", + "vid.v", + "viota.m", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vminu.vv", + "vminu.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmsbf.m", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsif.m", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmsof.m", + "vmulhu.vv", + "vmulhu.vx", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vredmaxu.vs", + "vredminu.vs", + "vremu.vv", + "vremu.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vssubu.vv", + "vssubu.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwredsumu.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasub.vv", + "vasub.vx", + "vmax.vv", + "vmax.vx", + "vmin.vv", + "vmin.vx", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmax.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsum.vs", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccus.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmul.vv", + "vwmul.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vfmerge.vfm", + "vfmv.s.f", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isUnsigned1_nf(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "todo" +} diff --git a/t1/src/decoder/attribute/isVtype.scala b/t1/src/decoder/attribute/isVtype.scala new file mode 100644 index 0000000000..4f90120da0 --- /dev/null +++ b/t1/src/decoder/attribute/isVtype.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isVtype { + def apply(t1DecodePattern: T1DecodePattern): isVtype = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isVtype(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vaaddu.vv", + "vaadd.vv", + "vadc.vvm", + "vadd.vv", + "vand.vv", + "vasubu.vv", + "vasub.vv", + "vcompress.vm", + "vcpop.m", + "vdivu.vv", + "vdiv.vv", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfdiv.vv", + "vfirst.m", + "vfmacc.vv", + "vfmadd.vv", + "vfmax.vv", + "vfmin.vv", + "vfmsac.vv", + "vfmsub.vv", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vv", + "vfnmadd.vv", + "vfnmsac.vv", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfsgnjn.vv", + "vfsgnj.vv", + "vfsgnjx.vv", + "vfsqrt.v", + "vfsub.vv", + "vfwadd.vv", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vv", + "vfwmsac.vv", + "vfwmul.vv", + "vfwnmacc.vv", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vv", + "vfwsub.wv", + "vid.v", + "viota.m", + "vmacc.vv", + "vmadc.vv", + "vmadc.vvm", + "vmadd.vv", + "vmand.mm", + "vmandn.mm", + "vmaxu.vv", + "vmax.vv", + "vmerge.vvm", + "vmfeq.vv", + "vmfle.vv", + "vmflt.vv", + "vmfne.vv", + "vminu.vv", + "vmin.vv", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbf.m", + "vmseq.vv", + "vmsif.m", + "vmsleu.vv", + "vmsle.vv", + "vmsltu.vv", + "vmslt.vv", + "vmsne.vv", + "vmsof.m", + "vmulhsu.vv", + "vmulhu.vv", + "vmulh.vv", + "vmul.vv", + "vmv.x.s", + "vmxnor.mm", + "vmxor.mm", + "vnclipu.wv", + "vnclip.wv", + "vnmsac.vv", + "vnmsub.vv", + "vnsra.wv", + "vnsrl.wv", + "vor.vv", + "vredand.vs", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredor.vs", + "vredsum.vs", + "vredxor.vs", + "vremu.vv", + "vrem.vv", + "vrgatherei16.vv", + "vrgather.vv", + "vsaddu.vv", + "vsadd.vv", + "vsbc.vvm", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vsll.vv", + "vsmul.vv", + "vsra.vv", + "vsrl.vv", + "vssra.vv", + "vssrl.vv", + "vssubu.vv", + "vssub.vv", + "vsub.vv", + "vwaddu.vv", + "vwaddu.wv", + "vwadd.vv", + "vwadd.wv", + "vwmaccsu.vv", + "vwmaccu.vv", + "vwmacc.vv", + "vwmulsu.vv", + "vwmulu.vv", + "vwmul.vv", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.wv", + "vwsub.vv", + "vwsub.wv", + "vxor.vv", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vx", + "vor.vi", + "vor.vx", + "vxor.vi", + "vxor.vx", + "vaaddu.vx", + "vaadd.vx", + "vadc.vim", + "vadc.vxm", + "vadd.vi", + "vadd.vx", + "vasubu.vx", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vx", + "vmax.vx", + "vminu.vx", + "vmin.vx", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vx", + "vmsltu.vx", + "vmslt.vx", + "vmsne.vi", + "vmsne.vx", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vx", + "vsbc.vxm", + "vssubu.vx", + "vssub.vx", + "vsub.vx", + "vwaddu.vx", + "vwaddu.wx", + "vwadd.vx", + "vwadd.wx", + "vwsubu.vx", + "vwsubu.wx", + "vwsub.vx", + "vwsub.wx", + "vnsra.wi", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wx", + "vsll.vi", + "vsll.vx", + "vsra.vi", + "vsra.vx", + "vsrl.vi", + "vsrl.vx", + "vssra.vi", + "vssra.vx", + "vssrl.vi", + "vssrl.vx", + "vmacc.vx", + "vmadd.vx", + "vmulhsu.vx", + "vmulhu.vx", + "vmulh.vx", + "vmul.vx", + "vnmsac.vx", + "vnmsub.vx", + "vsmul.vx", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vx", + "vwmacc.vx", + "vwmulsu.vx", + "vwmulu.vx", + "vwmul.vx", + "vdivu.vx", + "vdiv.vx", + "vfdiv.vf", + "vfrdiv.vf", + "vremu.vx", + "vrem.vx", + "vfadd.vf", + "vfmacc.vf", + "vfmadd.vf", + "vfmax.vf", + "vfmin.vf", + "vfmsac.vf", + "vfmsub.vf", + "vfmul.vf", + "vfnmacc.vf", + "vfnmadd.vf", + "vfnmsac.vf", + "vfnmsub.vf", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnj.vf", + "vfsgnjx.vf", + "vfsub.vf", + "vfwadd.vf", + "vfwadd.wf", + "vfwmacc.vf", + "vfwmsac.vf", + "vfwmul.vf", + "vfwnmacc.vf", + "vfwnmsac.vf", + "vfwsub.vf", + "vfwsub.wf", + "vmfeq.vf", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmflt.vf", + "vmfne.vf", + "vfmerge.vfm", + "vfmv.s.f", + "vmerge.vim", + "vmerge.vxm", + "vmv.s.x", + "vnclipu.wi", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wx", + "vrgather.vi", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isVtype(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "src1 is vtype." +} diff --git a/t1/src/decoder/attribute/isVwmacc.scala b/t1/src/decoder/attribute/isVwmacc.scala new file mode 100644 index 0000000000..55d637d83b --- /dev/null +++ b/t1/src/decoder/attribute/isVwmacc.scala @@ -0,0 +1,411 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isVwmacc { + def apply(t1DecodePattern: T1DecodePattern): isVwmacc = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isVwmacc(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmaccsu.vv", + "vwmaccu.vv", + "vwmacc.vv", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwredsumu.vs", + "vwredsum.vs", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isVwmacc(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "special MAC instruction, MAC use vd as source, it cross read vd. TODO: cross read vd + mac uop. " +} diff --git a/t1/src/decoder/attribute/isWidenreduce.scala b/t1/src/decoder/attribute/isWidenreduce.scala new file mode 100644 index 0000000000..7ac7da9534 --- /dev/null +++ b/t1/src/decoder/attribute/isWidenreduce.scala @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2022 Jiuyang Liu + +package org.chipsalliance.t1.rtl.decoder.attribute + +import org.chipsalliance.t1.rtl.decoder.T1DecodePattern + +object isWidenreduce { + def apply(t1DecodePattern: T1DecodePattern): isWidenreduce = + Seq( + y _ -> Y, + n _ -> N, + dc _ -> DC + ).collectFirst { + case (fn, tri) if fn(t1DecodePattern) => isWidenreduce(tri) + }.get + + def y(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vwredsumu.vs", + "vwredsum.vs", + ) + allMatched.contains(t1DecodePattern.instruction) + } + def n(t1DecodePattern: T1DecodePattern): Boolean = { + val allMatched = Seq( + "vand.vi", + "vand.vv", + "vand.vx", + "vmand.mm", + "vmandn.mm", + "vmnand.mm", + "vmnor.mm", + "vmor.mm", + "vmorn.mm", + "vmxnor.mm", + "vmxor.mm", + "vor.vi", + "vor.vv", + "vor.vx", + "vredand.vs", + "vredor.vs", + "vredxor.vs", + "vxor.vi", + "vxor.vv", + "vxor.vx", + "vaaddu.vv", + "vaaddu.vx", + "vaadd.vv", + "vaadd.vx", + "vadc.vim", + "vadc.vvm", + "vadc.vxm", + "vadd.vi", + "vadd.vv", + "vadd.vx", + "vasubu.vv", + "vasubu.vx", + "vasub.vv", + "vasub.vx", + "vmadc.vi", + "vmadc.vim", + "vmadc.vv", + "vmadc.vvm", + "vmadc.vx", + "vmadc.vxm", + "vmaxu.vv", + "vmaxu.vx", + "vmax.vv", + "vmax.vx", + "vminu.vv", + "vminu.vx", + "vmin.vv", + "vmin.vx", + "vmsbc.vv", + "vmsbc.vvm", + "vmsbc.vx", + "vmsbc.vxm", + "vmseq.vi", + "vmseq.vv", + "vmseq.vx", + "vmsgtu.vi", + "vmsgtu.vx", + "vmsgt.vi", + "vmsgt.vx", + "vmsleu.vi", + "vmsleu.vv", + "vmsleu.vx", + "vmsle.vi", + "vmsle.vv", + "vmsle.vx", + "vmsltu.vv", + "vmsltu.vx", + "vmslt.vv", + "vmslt.vx", + "vmsne.vi", + "vmsne.vv", + "vmsne.vx", + "vredmaxu.vs", + "vredmax.vs", + "vredminu.vs", + "vredmin.vs", + "vredsum.vs", + "vrsub.vi", + "vrsub.vx", + "vsaddu.vi", + "vsaddu.vv", + "vsaddu.vx", + "vsadd.vi", + "vsadd.vv", + "vsadd.vx", + "vsbc.vvm", + "vsbc.vxm", + "vssubu.vv", + "vssubu.vx", + "vssub.vv", + "vssub.vx", + "vsub.vv", + "vsub.vx", + "vwaddu.vv", + "vwaddu.vx", + "vwaddu.wv", + "vwaddu.wx", + "vwadd.vv", + "vwadd.vx", + "vwadd.wv", + "vwadd.wx", + "vwsubu.vv", + "vwsubu.vx", + "vwsubu.wv", + "vwsubu.wx", + "vwsub.vv", + "vwsub.vx", + "vwsub.wv", + "vwsub.wx", + "vnsra.wi", + "vnsra.wv", + "vnsra.wx", + "vnsrl.wi", + "vnsrl.wv", + "vnsrl.wx", + "vsll.vi", + "vsll.vv", + "vsll.vx", + "vsra.vi", + "vsra.vv", + "vsra.vx", + "vsrl.vi", + "vsrl.vv", + "vsrl.vx", + "vssra.vi", + "vssra.vv", + "vssra.vx", + "vssrl.vi", + "vssrl.vv", + "vssrl.vx", + "vmacc.vv", + "vmacc.vx", + "vmadd.vv", + "vmadd.vx", + "vmulhsu.vv", + "vmulhsu.vx", + "vmulhu.vv", + "vmulhu.vx", + "vmulh.vv", + "vmulh.vx", + "vmul.vv", + "vmul.vx", + "vnmsac.vv", + "vnmsac.vx", + "vnmsub.vv", + "vnmsub.vx", + "vsmul.vv", + "vsmul.vx", + "vwmaccsu.vv", + "vwmaccsu.vx", + "vwmaccus.vx", + "vwmaccu.vv", + "vwmaccu.vx", + "vwmacc.vv", + "vwmacc.vx", + "vwmulsu.vv", + "vwmulsu.vx", + "vwmulu.vv", + "vwmulu.vx", + "vwmul.vv", + "vwmul.vx", + "vdivu.vv", + "vdivu.vx", + "vdiv.vv", + "vdiv.vx", + "vfdiv.vf", + "vfdiv.vv", + "vfrdiv.vf", + "vfsqrt.v", + "vremu.vv", + "vremu.vx", + "vrem.vv", + "vrem.vx", + "vfadd.vf", + "vfadd.vv", + "vfclass.v", + "vfcvt.f.xu.v", + "vfcvt.f.x.v", + "vfcvt.rtz.x.f.v", + "vfcvt.rtz.xu.f.v", + "vfcvt.x.f.v", + "vfcvt.xu.f.v", + "vfmacc.vf", + "vfmacc.vv", + "vfmadd.vf", + "vfmadd.vv", + "vfmax.vf", + "vfmax.vv", + "vfmin.vf", + "vfmin.vv", + "vfmsac.vf", + "vfmsac.vv", + "vfmsub.vf", + "vfmsub.vv", + "vfmul.vf", + "vfmul.vv", + "vfmv.f.s", + "vfncvt.f.f.w", + "vfncvt.f.xu.w", + "vfncvt.f.x.w", + "vfncvt.rod.f.f.w", + "vfncvt.rtz.x.f.w", + "vfncvt.rtz.xu.f.w", + "vfncvt.x.f.w", + "vfncvt.xu.f.w", + "vfnmacc.vf", + "vfnmacc.vv", + "vfnmadd.vf", + "vfnmadd.vv", + "vfnmsac.vf", + "vfnmsac.vv", + "vfnmsub.vf", + "vfnmsub.vv", + "vfrec7.v", + "vfredmax.vs", + "vfredmin.vs", + "vfredosum.vs", + "vfredusum.vs", + "vfrsqrt7.v", + "vfrsub.vf", + "vfsgnjn.vf", + "vfsgnjn.vv", + "vfsgnj.vf", + "vfsgnj.vv", + "vfsgnjx.vf", + "vfsgnjx.vv", + "vfsub.vf", + "vfsub.vv", + "vfwadd.vf", + "vfwadd.vv", + "vfwadd.wf", + "vfwadd.wv", + "vfwcvt.f.f.v", + "vfwcvt.f.xu.v", + "vfwcvt.f.x.v", + "vfwcvt.rtz.x.f.v", + "vfwcvt.rtz.xu.f.v", + "vfwcvt.x.f.v", + "vfwcvt.xu.f.v", + "vfwmacc.vf", + "vfwmacc.vv", + "vfwmsac.vf", + "vfwmsac.vv", + "vfwmul.vf", + "vfwmul.vv", + "vfwnmacc.vf", + "vfwnmacc.vv", + "vfwnmsac.vf", + "vfwnmsac.vv", + "vfwredosum.vs", + "vfwredusum.vs", + "vfwsub.vf", + "vfwsub.vv", + "vfwsub.wf", + "vfwsub.wv", + "vmfeq.vf", + "vmfeq.vv", + "vmfge.vf", + "vmfgt.vf", + "vmfle.vf", + "vmfle.vv", + "vmflt.vf", + "vmflt.vv", + "vmfne.vf", + "vmfne.vv", + "vcpop.m", + "vfirst.m", + "vfmerge.vfm", + "vfmv.s.f", + "vid.v", + "vmerge.vim", + "vmerge.vvm", + "vmerge.vxm", + "vmsbf.m", + "vmsif.m", + "vmsof.m", + "vmv.s.x", + "vmv.x.s", + "vnclipu.wi", + "vnclipu.wv", + "vnclipu.wx", + "vnclip.wi", + "vnclip.wv", + "vnclip.wx", + "vrgatherei16.vv", + "vrgather.vi", + "vrgather.vv", + "vrgather.vx", + "vfslide1down.vf", + "vfslide1up.vf", + "vmv1r.v", + "vmv2r.v", + "vmv4r.v", + "vmv8r.v", + "viota.m", + "vsext.vf2", + "vsext.vf4", + "vsext.vf8", + "vzext.vf2", + "vzext.vf4", + "vzext.vf8", + "vcompress.vm", + "vslidedown.vi", + "vslideup.vi", + "vslide1down.vx", + "vslide1up.vx", + "vslidedown.vx", + "vslideup.vx", + "lsu", + ) + allMatched.contains(t1DecodePattern.instruction) + } + + def dc(t1DecodePattern: T1DecodePattern): Boolean = false +} + +case class isWidenreduce(value: TriState) extends BooleanDecodeAttribute { + override val description: String = "a special widen, only write dual vd from Top to element0 it doesn't cross. TODO: better name. " +}