/*========================== begin_copyright_notice ============================ Copyright (C) 2018-2021 Intel Corporation SPDX-License-Identifier: MIT ============================= end_copyright_notice ===========================*/ #ifndef IGA_NATIVE_INSTDECODER_HPP #define IGA_NATIVE_INSTDECODER_HPP #include "../../Frontend/Floats.hpp" #include "../../Frontend/IRToString.hpp" #include "../../IR/InstBuilder.hpp" #include "../../strings.hpp" #include "../BitProcessor.hpp" #include "Field.hpp" #include "Interface.hpp" #include "MInst.hpp" #include #include #include #include #include #include #include namespace iga { typedef std::function FormatFunction; static inline int nextPowerOfTwo(int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; } static inline PredCtrl decodePredCtrl(uint64_t bits) { return static_cast(bits); } static inline PredCtrl decodePredCtrlPvc(uint64_t bits) { switch (bits) { case 0: return PredCtrl::NONE; case 1: return PredCtrl::SEQ; case 2: return PredCtrl::ANY; case 3: return PredCtrl::ALL; } return static_cast(bits); } static inline ExecSize decodeExecSizeBits(uint64_t val) { switch (val) { case 0: return ExecSize::SIMD1; case 1: return ExecSize::SIMD2; case 2: return ExecSize::SIMD4; case 3: return ExecSize::SIMD8; case 4: return ExecSize::SIMD16; case 5: return ExecSize::SIMD32; default: return ExecSize::INVALID; } } static inline ChannelOffset decodeChannelOffsetBits(uint64_t val) { return static_cast(val); } static inline FlagModifier decodeFlagModifierBits(uint64_t val) { FlagModifier fm; switch (val) { case 0: fm = FlagModifier::NONE; break; case 1: fm = FlagModifier::EQ; break; case 2: fm = FlagModifier::NE; break; case 3: fm = FlagModifier::GT; break; case 4: fm = FlagModifier::GE; break; case 5: fm = FlagModifier::LT; break; case 6: fm = FlagModifier::LE; break; // case 7: reserved case 8: fm = FlagModifier::OV; break; case 9: fm = FlagModifier::UN; break; default: fm = static_cast(val); break; } return fm; } static inline SrcModifier decodeSrcModifierBits(uint64_t bits) { switch (bits) { case 0: return SrcModifier::NONE; case 1: return SrcModifier::ABS; case 2: return SrcModifier::NEG; case 3: return SrcModifier::NEG_ABS; default: return static_cast(bits); } } static inline FlagModifier decodeFlagModifier(uint64_t bits) { switch (bits) { case 0: return FlagModifier::NONE; case 1: return FlagModifier::EQ; case 2: return FlagModifier::NE; case 3: return FlagModifier::GT; case 4: return FlagModifier::GE; case 5: return FlagModifier::LT; case 6: return FlagModifier::LE; // case 8: return FlagModifier::OV; case 9: return FlagModifier::UN; default: return static_cast(bits); } } // // This is a generic template for instruction decoders for various GEN // platforms. Users can use this via inheritance or composition equally. // This class also decodes field by field for various debugging routines. // E.g. iga64 -Xifs ... decodes each field // // The naming convention is as follows: // // T decodeXXXX(Field fXXXX) // decodes something (an XXXX) using field fXXXX and store this into the // field list. This implies that fXXXX is properly part of the format and // thus will not overlap with any other field decoded. It also might // commit the field to the instruction builder. // // T peekXXXX(Field fXXXX) // decoes something, but quietly (don't add it to the list of // fields decoded). E.g. we might speculatively need to look at a field // that we might not want to add. // // TODO: template where P is PlatformInfo // for GEN-specific stuff use this var; e.g. P.decodeBasicRegType(...) struct InstDecoder { InstBuilder &builder; ErrorHandler &errorHandler; const Model &model; const OpSpec &os; MInst bits; FragmentList *fields; Loc loc; // instruction state ExecSize execSize; InstOptSet instOptSet; InstDecoder(InstBuilder &_builder, ErrorHandler &_errorHandler, const Model &_model, const OpSpec &_os, MInst _bits, FragmentList *_fields, Loc _loc) : builder(_builder), errorHandler(_errorHandler), model(_model), os(_os), bits(_bits), fields(_fields), loc(_loc), execSize(ExecSize::INVALID), instOptSet(0) {} bool isXeHpcPlus() const { return model.platform >= Platform::XE_HPC; } void reportError(const char *msg) { errorHandler.reportError(loc, msg); } void reportError(const std::string &msg) { errorHandler.reportError(loc, msg); } void reportWarning(const std::string &msg) { errorHandler.reportWarning(loc, msg); } void reportFieldError(const Field &f, const char *msg) { std::stringstream ss; ss << f.name << ": " << msg; reportError(ss.str()); } void reportFieldWarning(const Field &f, const char *msg) { std::stringstream ss; ss << f.name << ": " << msg; reportWarning(ss.str()); } void reportFieldErrorInvalidValue(const Field &f) { std::stringstream ss; reportFieldError(f, "invalid value"); } /////////////////////////////////////////// // PRIMITIVE FIELD ADDERS void addDecodedField(const Field &f, const std::string& meaning) { if (fields) { int encodedFragments = 0; for (const Fragment &fr : f.fragments) { if (fr.isInvalid()) break; else if (fr.isEncoded()) encodedFragments++; } for (const Fragment &fr : f.fragments) { if (fr.isInvalid()) break; else if (fr.isEncoded()) { addDecodedFragment(fr, meaning); } } } } void addDecodedFragment(const Fragment &fr, const std::string& val) { if (fields) fields->emplace_back(fr, val); } uint64_t decodeFragment(const Fragment &f) { addDecodedFragment(f, ""); return bits.getFragment(f); } uint64_t decodeFragment(const Fragment &f, FormatFunction fmt) { auto val = bits.getFragment(f); if (fields) { std::stringstream ss; fmt(val, ss); addDecodedFragment(f, ss.str()); } return val; } uint64_t decodeFieldWithFunction(const Fragment &f, FormatFunction fmt) { return decodeFragment(f, fmt); } void addReserved(int off, int len, const std::string &errStr = "?") { Fragment fRSVD("Reserved", off, len); auto b = bits.getFragment(fRSVD); addDecodedFragment(fRSVD, b != 0 ? errStr : ""); } void addReserved(const Fragment &f) { std::stringstream ss; ss << "? (shadows " << f.name << ")"; addReserved(f.offset, f.length, ss.str().c_str()); } void addReserved(const Field &f) { for (const Fragment &fr : f.fragments) { if (fr.isEncoded()) { addReserved(fr); } } } uint32_t decodeFieldU32(const Field &f) { addDecodedField(f, ""); return (uint32_t)bits.getField(f); } /////////////////////////////////////////////////////////////////////////// // one bit fields /////////////////////////////////////////////////////////////////////////// template T decodeField(const Field &f, T val0, const char *str0, T val1, const char *str1) { IGA_ASSERT(f.length() == 1, "field is >1 bit"); T val; const char *str = ""; auto b = bits.getField(f); switch (b) { case 0: val = val0; str = str0; break; case 1: val = val1; str = str1; break; default: val = val0; // for compiler warning IGA_ASSERT_FALSE("Unreachable"); break; // unreachable }; if (fields) { fields->emplace_back(f, str); } return val; } bool decodeBoolField(const Field &f, const char *falseMeaning, const char *trueMeaning) { return decodeField(f, false, falseMeaning, true, trueMeaning); } /////////////////////////////////////////////////////////////////////// // two bit fields /////////////////////////////////////////////////////////////////////// template T decodeField(const Field &f, T val0, const char *str0, T val1, const char *str1, T val2, const char *str2, T val3, const char *str3) { // IGA_ASSERT(f.length == 2, "field is not a two bits"); // we can have subset fields like Dst.RgnHz[0] in ternary IGA_ASSERT(f.length() <= 2, "field is <=2 bits"); T val; const char *str = ""; auto b = bits.getField(f); switch (b) { case 0: val = val0; str = str0; break; case 1: val = val1; str = str1; break; case 2: val = val2; str = str2; break; case 3: val = val3; str = str3; break; default: val = val0; // for compiler warning IGA_ASSERT_FALSE("Unreachable"); break; // unreachable }; if (fields) { fields->emplace_back(f, str); } return val; } /////////////////////////////////////////////////////////////////////// // multi bit fields /////////////////////////////////////////////////////////////////////// uint64_t decodeField(const Field &f, FormatFunction fmt) { auto val = bits.getField(f); if (fields) { std::stringstream ss; fmt(val, ss); fields->emplace_back(f, ss.str()); } return val; } template T decodeField(const Field &f, T invalid, std::initializer_list> vals) { IGA_ASSERT(nextPowerOfTwo((int)vals.size()) != f.length(), "field is wrong number of bits"); int i = 0; T retVal = invalid; const char *strVal = "?"; auto b = bits.getField(f); for (const auto &val : vals) { if (i == (int)b) { retVal = val.first; strVal = val.second; break; } i++; } if (i == (int)vals.size() || retVal == invalid) { // didn't find it retVal = invalid; strVal = "?"; reportFieldErrorInvalidValue(f); } if (fields) { fields->emplace_back(f, strVal); } return retVal; } /////////////////////////////////////////////////////////////////////// // generic GEN helpers /////////////////////////////////////////////////////////////////////// bool isMacro() const { return builder.isMacroOp(); } void decodeMaskCtrl(const Field &fMASKCTRL) { if (decodeBoolField(fMASKCTRL, "", "WrEn")) { builder.InstNoMask(loc); } } void decodePredication(const Field &fPREDINV, const Field &fPREDCTRL, const Field &fFLAGREG) { PredCtrl predCtrl = isXeHpcPlus() ? decodePredCtrlPvc(bits.getField(fPREDCTRL)) : decodePredCtrl(bits.getField(fPREDCTRL)); addDecodedField(fPREDCTRL, ToSyntax(predCtrl)); bool predInv = decodeBoolField(fPREDINV, "", "~"); if (predInv && predCtrl == PredCtrl::NONE) { reportFieldError(fPREDINV, "PredCtrl is not set, but PredInv is set"); } if (predCtrl != PredCtrl::NONE) { RegRef flagReg = peekFlagRegRef(fFLAGREG); builder.InstPredication(loc, predInv, flagReg, predCtrl); } } void decodeBrCtl(const Field &fBRCTL) { bool brCtl = decodeBoolField(fBRCTL, "", ".b"); builder.InstSubfunction(brCtl ? BranchCntrl::ON : BranchCntrl::OFF); } RegRef peekFlagRegRef(const Field &fFLAGREG) const { auto val = (uint32_t)bits.getField(fFLAGREG); return RegRef(val >> 1, val & 0x1); } RegRef decodeFlagReg(const Field &fFLAGREG) { // flag register decodeField(fFLAGREG, [](uint64_t bits, std::stringstream &ss) { ss << "f" << (bits >> 1) << "." << (bits & 0x1); }); return peekFlagRegRef(fFLAGREG); } void decodeFlagModifierField(const Field &fFLAGMOD, const Field &fFLAGREG) { RegRef flagReg = peekFlagRegRef(fFLAGREG); FlagModifier invalidModifier = static_cast(-1); FlagModifier zeroValue = FlagModifier::NONE; const char *zeroString = ""; if (os.is(Op::MATH) && isMacro()) { zeroValue = FlagModifier::EO; zeroString = "(eo) (early out)"; } // TODO: use decodeFlagModifier() and ToSyntax FlagModifier flagMod = decodeField(fFLAGMOD, invalidModifier, {{zeroValue, zeroString}, {FlagModifier::EQ, "(eq)"}, {FlagModifier::NE, "(ne)"}, {FlagModifier::GT, "(gt)"}, {FlagModifier::GE, "(ge)"}, {FlagModifier::LT, "(lt)"}, {FlagModifier::LE, "(le)"}, {invalidModifier, "?"}, {FlagModifier::OV, "(ov) (overflow)"}, {FlagModifier::UN, "(un) (unordered)"}}); builder.InstFlagModifier(flagReg, flagMod); } ImmVal decodeImm32(const Field &fIMM32L, Type t) { std::stringstream ss; ImmVal immVal; uint64_t val = bits.getField(fIMM32L); // // TODO: determine if ImmVal should store everything as s64 // otherwise I need to normalize what the GED parser and decoder // a specific exmaple: // NATIVE: 0x0000000000008000 // GED: 0xFFFFFFFFFFFF8000 // // NATIVE: src0: PC[0]: // mov: 61 00 03 00 a0 45 05 01 00 00 00 00 00 80 00 80 // mov (8|M0) r1.0<1>:f -32768:w // GED takes a 64b value switch (t) { case Type::UW: immVal = (uint16_t)val; ss << std::hex << (uint16_t)val; break; case Type::UD: immVal = (uint32_t)val; ss << std::hex << "0x" << (uint32_t)val; break; case Type::W: immVal = (int16_t)val; immVal.s64 = immVal.s16; ss << std::dec << (int16_t)val; break; case Type::D: immVal = (int32_t)val; immVal.s64 = immVal.s32; ss << std::dec << (int32_t)val; break; case Type::HF: immVal = (uint16_t)val; immVal.kind = ImmVal::Kind::F16; FormatFloat(ss, FloatFromBits((uint16_t)val)); break; case Type::F: immVal = FloatFromBits((uint32_t)val); FormatFloat(ss, FloatFromBits((uint32_t)val)); break; case Type::V: case Type::UV: immVal = (uint32_t)val; ss << "("; for (int i = 7; i >= 0; i--) { if (i < 7) ss << ','; if (t == Type::V) { ss << std::hex << getSignedBits((int64_t)val, i * 4, 4); } else { ss << std::dec << getBits(val, i * 4, 4); } } ss << ")"; break; case Type::VF: immVal = (uint32_t)val; ss << "("; for (int i = 3; i >= 0; i--) { if (i < 3) ss << ','; FormatFloat(ss, (uint8_t)getBits(val, i * 8, 8)); } ss << ")"; break; break; default: immVal = (uint32_t)0; reportFieldError(fIMM32L, "invalid type for 32b IMM"); ss << "?"; } addDecodedField(fIMM32L, ss.str()); return immVal; } ImmVal decodeImm64(const Field &fIMM32L, const Field &fIMM32H, Type type) { uint64_t lo = bits.getField(fIMM32L); uint64_t hi = bits.getField(fIMM32H); ImmVal immVal; immVal.u64 = ((hi << 32) | lo); ; std::stringstream ss; ss << "("; switch (type) { case Type::DF: immVal.kind = ImmVal::Kind::F64; FormatFloat(ss, FloatFromBits(immVal.u64)); break; case Type::UQ: immVal.kind = ImmVal::Kind::U64; ss << immVal.u64; break; case Type::Q: immVal.kind = ImmVal::Kind::S64; ss << immVal.s64; break; default: ss << "ERROR: expected 64b type"; reportError("ERROR: expected 64b type"); } ss << ")"; addDecodedField(fIMM32L, "LO32" + ss.str()); addDecodedField(fIMM32H, "HI32" + ss.str()); return immVal; } void decodeExecOffsetInfo(const Field &fEXECSIZE, const Field &fCHANOFF) { execSize = decodeExecSizeBits(bits.getField(fEXECSIZE)); if (execSize == ExecSize::INVALID) { reportFieldErrorInvalidValue(fEXECSIZE); } std::stringstream ssEs; ssEs << "(" << ToSyntax(execSize) << "|...)"; addDecodedField(fEXECSIZE, ssEs.str()); auto chOffBits = bits.getField(fCHANOFF); ChannelOffset chOff = decodeChannelOffsetBits(chOffBits); if (chOff < ChannelOffset::M0 || chOff > ChannelOffset::M28) { reportFieldErrorInvalidValue(fCHANOFF); } std::stringstream ssCo; ssCo << "(..." << ToSyntax(chOff) << ")"; addDecodedField(fCHANOFF, ssCo.str()); builder.InstExecInfo(loc, execSize, loc, chOff); } DstModifier decodeDstModifier(const Field &fSATURATE) { return decodeField(fSATURATE, DstModifier::NONE, "", DstModifier::SAT, "(sat)"); } SrcModifier decodeSrcMods(const Field &fSRCMODS) { return decodeField(fSRCMODS, SrcModifier::NONE, "", SrcModifier::ABS, "(abs)", SrcModifier::NEG, os.isBitwise() ? "~" : "-", SrcModifier::NEG_ABS, "-(abs)"); } MathMacroExt decodeMathMacroReg(const Field &fSPCACC) { addReserved(fSPCACC.fragments[0].offset + 4, 1); return decodeMathMacroRegField(fSPCACC); } void decodeSubReg(OperandInfo &opInfo, const Field &fSUBREG) { decodeSubRegWithType(opInfo, fSUBREG, opInfo.type, ToSyntax(opInfo.type)); } // e.g. for subregisters without proper types void decodeSubRegWithImplicitType(OperandInfo &opInfo, const Field &fSUBREG, Type t) { decodeSubRegWithType(opInfo, fSUBREG, t, ""); } void decodeSubRegWithType(OperandInfo &opInfo, const Field &fSUBREG, Type type, const std::string &typeSyntax) { auto srb = (int)bits.getField(fSUBREG); auto scaled = BinaryOffsetToSubReg(srb, opInfo.regOpName, type, model.platform); auto unscaled = SubRegToBinaryOffset((int)scaled, opInfo.regOpName, type, model.platform); if ((int)unscaled != srb) { reportFieldError(fSUBREG, "subregister offset is misaligned for type size"); } opInfo.regOpReg.subRegNum = scaled; std::stringstream ss; ss << "." << (int)opInfo.regOpReg.subRegNum << typeSyntax; addDecodedField(fSUBREG, ss.str()); } void decodeRegDirectFields(OpIx opIndex, OperandInfo &opInfo, const Field &fREGFILE, // direct only const Field &fSPCACC, const Field &fSUBREG, const Field &fREG) { decodeRegFields(opInfo, fREGFILE, fREG); if (isMacro()) { opInfo.kind = Operand::Kind::MACRO; opInfo.regOpMathMacroExtReg = decodeMathMacroRegField(fSPCACC); addReserved(fSPCACC.fragments[0].offset + fSPCACC.fragments[0].length, 1); if (!IsTernary(opIndex) && (IsDst(opIndex) || ToSrcIndex(opIndex) == 0) && fSUBREG.length() > 1 && fSUBREG.fragments[0].length == 1) { // for binary macros, the low of subreg is stowed elsewhere addReserved(fSUBREG.fragments[0]); } } else { opInfo.kind = Operand::Kind::DIRECT; decodeSubReg(opInfo, fSUBREG); } } void decodeRegFields(OperandInfo &opInfo, const Field &fREGFILE, const Field &fREG) { bool isGrf = decodeBoolField(fREGFILE, "ARF", "GRF"); std::stringstream ss; auto regVal = bits.getField(fREG); if (isGrf) { opInfo.regOpName = RegName::GRF_R; opInfo.regOpReg.regNum = (uint16_t)regVal; ss << "r" << regVal; } else { readArfRegisterInfo(opInfo, fREG, ss); } addDecodedField(fREG, ss.str()); } // factored out so decodeInstSendDstOperand can share it void readArfRegisterInfo(OperandInfo &opInfo, const Field &fREG, std::stringstream &ssDesc) { auto regVal = bits.getField(fREG); const RegInfo *regInfo = model.lookupArfRegInfoByRegNum((uint8_t)regVal); if (regInfo == nullptr) { opInfo.regOpName = RegName::INVALID; ssDesc << "invalid ARF"; std::stringstream ssErr; ssErr << "invalid ARF Reg (" << fmtHex(regVal, 2) << ")"; reportFieldError(fREG, ssErr.str().c_str()); return; } // opInfo.regOpName = regInfo->regName; ssDesc << regInfo->syntax; int arfReg = 0; if (regVal > 0xFF || !regInfo->decode((uint8_t)regVal, arfReg)) { ssDesc << arfReg << "?"; std::stringstream ss; ss << regInfo->syntax << arfReg << " is out of bounds"; reportFieldError(fREG, ss.str().c_str()); } else { if (regInfo->hasRegNum()) { ssDesc << arfReg; } opInfo.regOpReg.regNum = (uint16_t)arfReg; if (regInfo->regNumBase > 0) { // if the register covers to another, let's tell // them which uint8_t coverRegBits = (uint8_t)(regVal & 0xF0); const RegInfo *coverRegInfo = model.lookupArfRegInfoByRegNum(coverRegBits); if (coverRegInfo) { // e.g. XE+ acc10 is mme2 ssDesc << " (" << coverRegInfo->syntax << (regVal & 0xF) << ")"; } } } } MathMacroExt decodeMathMacroRegField(const Field &fSPCACC) { return decodeField(fSPCACC, MathMacroExt::INVALID, {{MathMacroExt::MME0, ".mme0"}, {MathMacroExt::MME1, ".mme1"}, {MathMacroExt::MME2, ".mme2"}, {MathMacroExt::MME3, ".mme3"}, {MathMacroExt::MME4, ".mme4"}, {MathMacroExt::MME5, ".mme5"}, {MathMacroExt::MME6, ".mme6"}, {MathMacroExt::MME7, ".mme7"}, {MathMacroExt::NOMME, ".nomme"}}); } bool decodeInstOpt(const Field &fINSTOPT, InstOpt opt) { IGA_ASSERT(fINSTOPT.length() == 1, "inst opt field is >1 bit"); std::stringstream ss; bool z = bits.getField(fINSTOPT) != 0; if (z) { instOptSet.add(opt); ss << "{" << ToSyntax(opt) << "}"; } addDecodedField(fINSTOPT, ss.str()); return z; } }; // InstDecoder } // namespace iga #endif // IGA_NATIVE_INSTDECODER_HPP