diff --git a/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp b/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp index 287bc4781..a5b9b99a7 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp @@ -447,4 +447,264 @@ uint32_t Program::GetDisassemblyLine(uint32_t instruction) const return m_Instructions[RDCMIN(m_Instructions.size() - 1, (size_t)instruction)].line; } +// see http://msdn.microsoft.com/en-us/library/windows/desktop/bb219840(v=vs.85).aspx +// for details of these opcodes +size_t NumOperands(OpcodeType op) +{ + switch(op) + { + case OPCODE_BREAK: + case OPCODE_CONTINUE: + case OPCODE_CUT: + case OPCODE_DEFAULT: + case OPCODE_ELSE: + case OPCODE_EMIT: + case OPCODE_EMITTHENCUT: + case OPCODE_ENDIF: + case OPCODE_ENDLOOP: + case OPCODE_ENDSWITCH: + case OPCODE_LOOP: + case OPCODE_NOP: + case OPCODE_RET: + case OPCODE_SYNC: + case OPCODE_ABORT: + case OPCODE_DEBUGBREAK: + + case OPCODE_HS_CONTROL_POINT_PHASE: + case OPCODE_HS_FORK_PHASE: + case OPCODE_HS_JOIN_PHASE: + case OPCODE_HS_DECLS: return 0; + case OPCODE_BREAKC: + case OPCODE_CONTINUEC: + case OPCODE_CALL: + case OPCODE_CASE: + case OPCODE_CUT_STREAM: + case OPCODE_DISCARD: + case OPCODE_EMIT_STREAM: + case OPCODE_EMITTHENCUT_STREAM: + case OPCODE_IF: + case OPCODE_INTERFACE_CALL: + case OPCODE_LABEL: + case OPCODE_RETC: + case OPCODE_SWITCH: return 1; + case OPCODE_BFREV: + case OPCODE_BUFINFO: + case OPCODE_CALLC: + case OPCODE_COUNTBITS: + case OPCODE_DERIV_RTX: + case OPCODE_DERIV_RTY: + case OPCODE_DERIV_RTX_COARSE: + case OPCODE_DERIV_RTX_FINE: + case OPCODE_DERIV_RTY_COARSE: + case OPCODE_DERIV_RTY_FINE: + case OPCODE_DMOV: + case OPCODE_DTOF: + case OPCODE_EXP: + case OPCODE_F32TOF16: + case OPCODE_F16TOF32: + case OPCODE_FIRSTBIT_HI: + case OPCODE_FIRSTBIT_LO: + case OPCODE_FIRSTBIT_SHI: + case OPCODE_FRC: + case OPCODE_FTOD: + case OPCODE_FTOI: + case OPCODE_FTOU: + case OPCODE_IMM_ATOMIC_ALLOC: + case OPCODE_IMM_ATOMIC_CONSUME: + case OPCODE_INEG: + case OPCODE_ITOF: + case OPCODE_LOG: + case OPCODE_MOV: + case OPCODE_NOT: + case OPCODE_RCP: + case OPCODE_ROUND_NE: + case OPCODE_ROUND_NI: + case OPCODE_ROUND_PI: + case OPCODE_ROUND_Z: + case OPCODE_RSQ: + case OPCODE_SAMPLE_INFO: + case OPCODE_SQRT: + case OPCODE_UTOF: + case OPCODE_EVAL_CENTROID: + case OPCODE_DRCP: + case OPCODE_DTOI: + case OPCODE_DTOU: + case OPCODE_ITOD: + case OPCODE_UTOD: + case OPCODE_CHECK_ACCESS_FULLY_MAPPED: return 2; + case OPCODE_AND: + case OPCODE_ADD: + case OPCODE_ATOMIC_AND: + case OPCODE_ATOMIC_OR: + case OPCODE_ATOMIC_XOR: + case OPCODE_ATOMIC_IADD: + case OPCODE_ATOMIC_IMAX: + case OPCODE_ATOMIC_IMIN: + case OPCODE_ATOMIC_UMAX: + case OPCODE_ATOMIC_UMIN: + case OPCODE_DADD: + case OPCODE_DIV: + case OPCODE_DP2: + case OPCODE_DP3: + case OPCODE_DP4: + case OPCODE_DEQ: + case OPCODE_DGE: + case OPCODE_DLT: + case OPCODE_DMAX: + case OPCODE_DMIN: + case OPCODE_DMUL: + case OPCODE_DNE: + case OPCODE_EQ: + case OPCODE_GE: + case OPCODE_IADD: + case OPCODE_IEQ: + case OPCODE_IGE: + case OPCODE_ILT: + case OPCODE_IMAX: + case OPCODE_IMIN: + case OPCODE_INE: + case OPCODE_ISHL: + case OPCODE_ISHR: + case OPCODE_LD: + case OPCODE_LD_RAW: + case OPCODE_LD_UAV_TYPED: + case OPCODE_LT: + case OPCODE_MAX: + case OPCODE_MIN: + case OPCODE_MUL: + case OPCODE_NE: + case OPCODE_OR: + case OPCODE_RESINFO: + case OPCODE_SAMPLE_POS: + case OPCODE_SINCOS: + case OPCODE_STORE_RAW: + case OPCODE_STORE_UAV_TYPED: + case OPCODE_UGE: + case OPCODE_ULT: + case OPCODE_UMAX: + case OPCODE_UMIN: + case OPCODE_USHR: + case OPCODE_XOR: + case OPCODE_EVAL_SNAPPED: + case OPCODE_EVAL_SAMPLE_INDEX: + case OPCODE_DDIV: return 3; + case OPCODE_ATOMIC_CMP_STORE: + case OPCODE_DMOVC: + case OPCODE_GATHER4: + case OPCODE_IBFE: + case OPCODE_IMAD: + case OPCODE_IMM_ATOMIC_IADD: + case OPCODE_IMM_ATOMIC_AND: + case OPCODE_IMM_ATOMIC_OR: + case OPCODE_IMM_ATOMIC_XOR: + case OPCODE_IMM_ATOMIC_EXCH: + case OPCODE_IMM_ATOMIC_IMAX: + case OPCODE_IMM_ATOMIC_IMIN: + case OPCODE_IMM_ATOMIC_UMAX: + case OPCODE_IMM_ATOMIC_UMIN: + case OPCODE_IMUL: + case OPCODE_LD_MS: + case OPCODE_LD_STRUCTURED: + case OPCODE_LOD: + case OPCODE_MAD: + case OPCODE_MOVC: + case OPCODE_SAMPLE: + case OPCODE_STORE_STRUCTURED: + case OPCODE_UADDC: + case OPCODE_UBFE: + case OPCODE_UDIV: + case OPCODE_UMAD: + case OPCODE_UMUL: + case OPCODE_USUBB: + case OPCODE_DFMA: + case OPCODE_MSAD: + case OPCODE_LD_FEEDBACK: + case OPCODE_LD_RAW_FEEDBACK: + case OPCODE_LD_UAV_TYPED_FEEDBACK: return 4; + case OPCODE_BFI: + case OPCODE_GATHER4_C: + case OPCODE_GATHER4_PO: + case OPCODE_IMM_ATOMIC_CMP_EXCH: + case OPCODE_SAMPLE_C: + case OPCODE_SAMPLE_C_LZ: + case OPCODE_SAMPLE_L: + case OPCODE_SAMPLE_B: + case OPCODE_SWAPC: + case OPCODE_GATHER4_FEEDBACK: + case OPCODE_LD_MS_FEEDBACK: + case OPCODE_LD_STRUCTURED_FEEDBACK: return 5; + case OPCODE_GATHER4_PO_C: + case OPCODE_SAMPLE_D: + case OPCODE_SAMPLE_CLAMP_FEEDBACK: + case OPCODE_SAMPLE_C_CLAMP_FEEDBACK: + case OPCODE_SAMPLE_C_LZ_FEEDBACK: + case OPCODE_SAMPLE_L_FEEDBACK: + case OPCODE_SAMPLE_B_CLAMP_FEEDBACK: + case OPCODE_GATHER4_C_FEEDBACK: + case OPCODE_GATHER4_PO_FEEDBACK: return 6; + case OPCODE_SAMPLE_D_CLAMP_FEEDBACK: + case OPCODE_GATHER4_PO_C_FEEDBACK: + return 7; + + // custom data doesn't have particular operands + case OPCODE_CUSTOMDATA: + default: break; + } + + RDCERR("Unknown opcode: %u", op); + return 0xffffffff; +} + +bool IsDeclaration(OpcodeType op) +{ + // isDecl means not a real instruction, just a declaration type token + bool isDecl = false; + isDecl = isDecl || (op >= OPCODE_DCL_RESOURCE && op <= OPCODE_DCL_GLOBAL_FLAGS); + isDecl = isDecl || (op >= OPCODE_DCL_STREAM && op <= OPCODE_DCL_RESOURCE_STRUCTURED); + isDecl = isDecl || (op == OPCODE_DCL_GS_INSTANCE_COUNT); + isDecl = isDecl || (op == OPCODE_HS_DECLS); + isDecl = isDecl || (op == OPCODE_CUSTOMDATA); + + return isDecl; +} + +bool IsInput(OperandType oper) +{ + switch(oper) + { + case TYPE_INPUT: + case TYPE_INPUT_PRIMITIVEID: + case TYPE_INPUT_FORK_INSTANCE_ID: + case TYPE_INPUT_JOIN_INSTANCE_ID: + case TYPE_INPUT_CONTROL_POINT: + // this is an input, yes it's confusing. + case TYPE_OUTPUT_CONTROL_POINT_ID: + case TYPE_INPUT_PATCH_CONSTANT: + case TYPE_INPUT_DOMAIN_POINT: + case TYPE_INPUT_THREAD_ID: + case TYPE_INPUT_THREAD_GROUP_ID: + case TYPE_INPUT_THREAD_ID_IN_GROUP: + case TYPE_INPUT_COVERAGE_MASK: + case TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED: + case TYPE_INPUT_GS_INSTANCE_ID: return true; + default: break; + } + return false; +} + +bool IsOutput(OperandType oper) +{ + switch(oper) + { + case TYPE_OUTPUT: + case TYPE_OUTPUT_DEPTH: + case TYPE_OUTPUT_COVERAGE_MASK: + case TYPE_OUTPUT_DEPTH_GREATER_EQUAL: + case TYPE_OUTPUT_DEPTH_LESS_EQUAL: + case TYPE_OUTPUT_STENCIL_REF: return true; + default: break; + } + return false; +} + }; // namespace DXBCBytecode diff --git a/renderdoc/driver/shaders/dxbc/dxbc_bytecode.h b/renderdoc/driver/shaders/dxbc/dxbc_bytecode.h index d9e45ac76..fe09ce975 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_bytecode.h +++ b/renderdoc/driver/shaders/dxbc/dxbc_bytecode.h @@ -39,7 +39,8 @@ struct Reflection; }; namespace DXBCBytecode -{ ///////////////////////////////////////////////////////////////////////// +{ +///////////////////////////////////////////////////////////////////////// // Enums for use below. If you're reading this you might want to skip to // the main structures after this section. ///////////////////////////////////////////////////////////////////////// @@ -318,6 +319,9 @@ enum OpcodeType NUM_OPCODES, }; +size_t NumOperands(OpcodeType op); +bool IsDeclaration(OpcodeType op); + enum CustomDataClass { CUSTOMDATA_COMMENT = 0, @@ -417,6 +421,9 @@ enum OperandType NUM_OPERAND_TYPES, }; +bool IsInput(OperandType oper); +bool IsOutput(OperandType oper); + enum OperandIndexType { INDEX_IMMEDIATE32 = 0, // 0 diff --git a/renderdoc/driver/shaders/dxbc/dxbc_disassemble.cpp b/renderdoc/driver/shaders/dxbc/dxbc_disassemble.cpp index 22f9718c5..2eaa18b82 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_disassemble.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_disassemble.cpp @@ -249,15 +249,7 @@ static MaskedElement MinPrecision; static MaskedElement NonUniform; }; -size_t NumOperands(OpcodeType op); rdcstr toString(const uint32_t values[], uint32_t numComps); -char *toString(OpcodeType op); -char *toString(ResourceDimension dim); -char *toString(DXBC::ResourceRetType type); -char *toString(ResinfoRetType type); -char *toString(InterpolationMode type); -char *SystemValueToString(DXBC::SVSemantic type); -bool IsDeclaration(OpcodeType op); bool Operand::operator==(const Operand &o) const { @@ -1380,7 +1372,7 @@ bool Program::ExtractDecl(uint32_t *&tokenStream, Declaration &retDecl, bool fri tokenStream++; - retDecl.str = toString(op); + retDecl.str = ToStr(op); if(op == OPCODE_DCL_GLOBAL_FLAGS) { @@ -1569,7 +1561,7 @@ bool Program::ExtractDecl(uint32_t *&tokenStream, Declaration &retDecl, bool fri retDecl.str += retDecl.operand.toString(m_Reflection, flags | ToString::ShowSwizzle); retDecl.str += ", "; - retDecl.str += SystemValueToString(retDecl.systemValue); + retDecl.str += ToStr(retDecl.systemValue); } else if(op == OPCODE_DCL_STREAM) { @@ -1635,17 +1627,17 @@ bool Program::ExtractDecl(uint32_t *&tokenStream, Declaration &retDecl, bool fri retDecl.resType[3] = Decl::ReturnTypeW.Get(ResourceReturnTypeToken); retDecl.str += "_"; - retDecl.str += toString(retDecl.dim); + retDecl.str += ToStr(retDecl.dim); retDecl.str += " "; retDecl.str += "("; - retDecl.str += toString(retDecl.resType[0]); + retDecl.str += ToStr(retDecl.resType[0]); retDecl.str += ","; - retDecl.str += toString(retDecl.resType[1]); + retDecl.str += ToStr(retDecl.resType[1]); retDecl.str += ","; - retDecl.str += toString(retDecl.resType[2]); + retDecl.str += ToStr(retDecl.resType[2]); retDecl.str += ","; - retDecl.str += toString(retDecl.resType[3]); + retDecl.str += ToStr(retDecl.resType[3]); retDecl.str += ")"; retDecl.str += " " + retDecl.operand.toString(m_Reflection, flags); @@ -1673,7 +1665,7 @@ bool Program::ExtractDecl(uint32_t *&tokenStream, Declaration &retDecl, bool fri RDCASSERT(ret); retDecl.str += " "; - retDecl.str += toString(retDecl.interpolation); + retDecl.str += ToStr(retDecl.interpolation); retDecl.str += " "; retDecl.str += retDecl.operand.toString(m_Reflection, flags | ToString::ShowSwizzle); @@ -1927,7 +1919,7 @@ bool Program::ExtractDecl(uint32_t *&tokenStream, Declaration &retDecl, bool fri retDecl.rov = Decl::RasterizerOrderedAccess.Get(OpcodeToken0); retDecl.str += "_"; - retDecl.str += toString(retDecl.dim); + retDecl.str += ToStr(retDecl.dim); if(retDecl.globallyCoherant) retDecl.str += "_glc"; @@ -1946,13 +1938,13 @@ bool Program::ExtractDecl(uint32_t *&tokenStream, Declaration &retDecl, bool fri retDecl.str += " "; retDecl.str += "("; - retDecl.str += toString(retDecl.resType[0]); + retDecl.str += ToStr(retDecl.resType[0]); retDecl.str += ","; - retDecl.str += toString(retDecl.resType[1]); + retDecl.str += ToStr(retDecl.resType[1]); retDecl.str += ","; - retDecl.str += toString(retDecl.resType[2]); + retDecl.str += ToStr(retDecl.resType[2]); retDecl.str += ","; - retDecl.str += toString(retDecl.resType[3]); + retDecl.str += ToStr(retDecl.resType[3]); retDecl.str += ")"; retDecl.str += " "; @@ -2184,7 +2176,7 @@ bool Program::ExtractOperation(uint32_t *&tokenStream, Operation &retOp, bool fr tokenStream++; - retOp.str = toString(op); + retOp.str = ToStr(op); while(extended) { @@ -2217,13 +2209,13 @@ bool Program::ExtractOperation(uint32_t *&tokenStream, Operation &retOp, bool fr { retOp.stride = ExtendedOpcode::BufferStride.Get(OpcodeTokenN); - retOp.str += - StringFormat::Fmt("_indexable(%s, stride=%u)", toString(retOp.resDim), retOp.stride); + retOp.str += StringFormat::Fmt("_indexable(%s, stride=%u)", ToStr(retOp.resDim).c_str(), + retOp.stride); } else { retOp.str += "("; - retOp.str += toString(retOp.resDim); + retOp.str += ToStr(retOp.resDim); retOp.str += ")"; } } @@ -2235,13 +2227,13 @@ bool Program::ExtractOperation(uint32_t *&tokenStream, Operation &retOp, bool fr retOp.resType[3] = ExtendedOpcode::ReturnTypeW.Get(OpcodeTokenN); retOp.str += "("; - retOp.str += toString(retOp.resType[0]); + retOp.str += ToStr(retOp.resType[0]); retOp.str += ","; - retOp.str += toString(retOp.resType[1]); + retOp.str += ToStr(retOp.resType[1]); retOp.str += ","; - retOp.str += toString(retOp.resType[2]); + retOp.str += ToStr(retOp.resType[2]); retOp.str += ","; - retOp.str += toString(retOp.resType[3]); + retOp.str += ToStr(retOp.resType[3]); retOp.str += ")"; } @@ -2253,7 +2245,7 @@ bool Program::ExtractOperation(uint32_t *&tokenStream, Operation &retOp, bool fr if(op == OPCODE_RESINFO) { retOp.str += "_"; - retOp.str += toString(retOp.resinfoRetType); + retOp.str += ToStr(retOp.resinfoRetType); } if(op == OPCODE_SYNC) @@ -2364,217 +2356,6 @@ bool Program::ExtractOperation(uint32_t *&tokenStream, Operation &retOp, bool fr return true; } -//////////////////////////////////////////////////////////// -// boring tedious long switch statement style functions - -// see http://msdn.microsoft.com/en-us/library/windows/desktop/bb219840(v=vs.85).aspx -// for details of these opcodes -size_t NumOperands(OpcodeType op) -{ - switch(op) - { - case OPCODE_BREAK: - case OPCODE_CONTINUE: - case OPCODE_CUT: - case OPCODE_DEFAULT: - case OPCODE_ELSE: - case OPCODE_EMIT: - case OPCODE_EMITTHENCUT: - case OPCODE_ENDIF: - case OPCODE_ENDLOOP: - case OPCODE_ENDSWITCH: - case OPCODE_LOOP: - case OPCODE_NOP: - case OPCODE_RET: - case OPCODE_SYNC: - case OPCODE_ABORT: - case OPCODE_DEBUGBREAK: - - case OPCODE_HS_CONTROL_POINT_PHASE: - case OPCODE_HS_FORK_PHASE: - case OPCODE_HS_JOIN_PHASE: - case OPCODE_HS_DECLS: return 0; - case OPCODE_BREAKC: - case OPCODE_CONTINUEC: - case OPCODE_CALL: - case OPCODE_CASE: - case OPCODE_CUT_STREAM: - case OPCODE_DISCARD: - case OPCODE_EMIT_STREAM: - case OPCODE_EMITTHENCUT_STREAM: - case OPCODE_IF: - case OPCODE_INTERFACE_CALL: - case OPCODE_LABEL: - case OPCODE_RETC: - case OPCODE_SWITCH: return 1; - case OPCODE_BFREV: - case OPCODE_BUFINFO: - case OPCODE_CALLC: - case OPCODE_COUNTBITS: - case OPCODE_DERIV_RTX: - case OPCODE_DERIV_RTY: - case OPCODE_DERIV_RTX_COARSE: - case OPCODE_DERIV_RTX_FINE: - case OPCODE_DERIV_RTY_COARSE: - case OPCODE_DERIV_RTY_FINE: - case OPCODE_DMOV: - case OPCODE_DTOF: - case OPCODE_EXP: - case OPCODE_F32TOF16: - case OPCODE_F16TOF32: - case OPCODE_FIRSTBIT_HI: - case OPCODE_FIRSTBIT_LO: - case OPCODE_FIRSTBIT_SHI: - case OPCODE_FRC: - case OPCODE_FTOD: - case OPCODE_FTOI: - case OPCODE_FTOU: - case OPCODE_IMM_ATOMIC_ALLOC: - case OPCODE_IMM_ATOMIC_CONSUME: - case OPCODE_INEG: - case OPCODE_ITOF: - case OPCODE_LOG: - case OPCODE_MOV: - case OPCODE_NOT: - case OPCODE_RCP: - case OPCODE_ROUND_NE: - case OPCODE_ROUND_NI: - case OPCODE_ROUND_PI: - case OPCODE_ROUND_Z: - case OPCODE_RSQ: - case OPCODE_SAMPLE_INFO: - case OPCODE_SQRT: - case OPCODE_UTOF: - case OPCODE_EVAL_CENTROID: - case OPCODE_DRCP: - case OPCODE_DTOI: - case OPCODE_DTOU: - case OPCODE_ITOD: - case OPCODE_UTOD: - case OPCODE_CHECK_ACCESS_FULLY_MAPPED: return 2; - case OPCODE_AND: - case OPCODE_ADD: - case OPCODE_ATOMIC_AND: - case OPCODE_ATOMIC_OR: - case OPCODE_ATOMIC_XOR: - case OPCODE_ATOMIC_IADD: - case OPCODE_ATOMIC_IMAX: - case OPCODE_ATOMIC_IMIN: - case OPCODE_ATOMIC_UMAX: - case OPCODE_ATOMIC_UMIN: - case OPCODE_DADD: - case OPCODE_DIV: - case OPCODE_DP2: - case OPCODE_DP3: - case OPCODE_DP4: - case OPCODE_DEQ: - case OPCODE_DGE: - case OPCODE_DLT: - case OPCODE_DMAX: - case OPCODE_DMIN: - case OPCODE_DMUL: - case OPCODE_DNE: - case OPCODE_EQ: - case OPCODE_GE: - case OPCODE_IADD: - case OPCODE_IEQ: - case OPCODE_IGE: - case OPCODE_ILT: - case OPCODE_IMAX: - case OPCODE_IMIN: - case OPCODE_INE: - case OPCODE_ISHL: - case OPCODE_ISHR: - case OPCODE_LD: - case OPCODE_LD_RAW: - case OPCODE_LD_UAV_TYPED: - case OPCODE_LT: - case OPCODE_MAX: - case OPCODE_MIN: - case OPCODE_MUL: - case OPCODE_NE: - case OPCODE_OR: - case OPCODE_RESINFO: - case OPCODE_SAMPLE_POS: - case OPCODE_SINCOS: - case OPCODE_STORE_RAW: - case OPCODE_STORE_UAV_TYPED: - case OPCODE_UGE: - case OPCODE_ULT: - case OPCODE_UMAX: - case OPCODE_UMIN: - case OPCODE_USHR: - case OPCODE_XOR: - case OPCODE_EVAL_SNAPPED: - case OPCODE_EVAL_SAMPLE_INDEX: - case OPCODE_DDIV: return 3; - case OPCODE_ATOMIC_CMP_STORE: - case OPCODE_DMOVC: - case OPCODE_GATHER4: - case OPCODE_IBFE: - case OPCODE_IMAD: - case OPCODE_IMM_ATOMIC_IADD: - case OPCODE_IMM_ATOMIC_AND: - case OPCODE_IMM_ATOMIC_OR: - case OPCODE_IMM_ATOMIC_XOR: - case OPCODE_IMM_ATOMIC_EXCH: - case OPCODE_IMM_ATOMIC_IMAX: - case OPCODE_IMM_ATOMIC_IMIN: - case OPCODE_IMM_ATOMIC_UMAX: - case OPCODE_IMM_ATOMIC_UMIN: - case OPCODE_IMUL: - case OPCODE_LD_MS: - case OPCODE_LD_STRUCTURED: - case OPCODE_LOD: - case OPCODE_MAD: - case OPCODE_MOVC: - case OPCODE_SAMPLE: - case OPCODE_STORE_STRUCTURED: - case OPCODE_UADDC: - case OPCODE_UBFE: - case OPCODE_UDIV: - case OPCODE_UMAD: - case OPCODE_UMUL: - case OPCODE_USUBB: - case OPCODE_DFMA: - case OPCODE_MSAD: - case OPCODE_LD_FEEDBACK: - case OPCODE_LD_RAW_FEEDBACK: - case OPCODE_LD_UAV_TYPED_FEEDBACK: return 4; - case OPCODE_BFI: - case OPCODE_GATHER4_C: - case OPCODE_GATHER4_PO: - case OPCODE_IMM_ATOMIC_CMP_EXCH: - case OPCODE_SAMPLE_C: - case OPCODE_SAMPLE_C_LZ: - case OPCODE_SAMPLE_L: - case OPCODE_SAMPLE_B: - case OPCODE_SWAPC: - case OPCODE_GATHER4_FEEDBACK: - case OPCODE_LD_MS_FEEDBACK: - case OPCODE_LD_STRUCTURED_FEEDBACK: return 5; - case OPCODE_GATHER4_PO_C: - case OPCODE_SAMPLE_D: - case OPCODE_SAMPLE_CLAMP_FEEDBACK: - case OPCODE_SAMPLE_C_CLAMP_FEEDBACK: - case OPCODE_SAMPLE_C_LZ_FEEDBACK: - case OPCODE_SAMPLE_L_FEEDBACK: - case OPCODE_SAMPLE_B_CLAMP_FEEDBACK: - case OPCODE_GATHER4_C_FEEDBACK: - case OPCODE_GATHER4_PO_FEEDBACK: return 6; - case OPCODE_SAMPLE_D_CLAMP_FEEDBACK: - case OPCODE_GATHER4_PO_C_FEEDBACK: - return 7; - - // custom data doesn't have particular operands - case OPCODE_CUSTOMDATA: - default: break; - } - - RDCERR("Unknown opcode: %u", op); - return 0xffffffff; -} - rdcstr toString(const uint32_t values[], uint32_t numComps) { rdcstr str = ""; @@ -2632,402 +2413,422 @@ rdcstr toString(const uint32_t values[], uint32_t numComps) return str; } -char *toString(OpcodeType op) -{ - switch(op) - { - case OPCODE_ADD: return "add"; - case OPCODE_AND: return "and"; - case OPCODE_BREAK: return "break"; - case OPCODE_BREAKC: return "breakc"; - case OPCODE_CALL: return "call"; - case OPCODE_CALLC: return "callc"; - case OPCODE_CASE: return "case"; - case OPCODE_CONTINUE: return "continue"; - case OPCODE_CONTINUEC: return "continuec"; - case OPCODE_CUT: return "cut"; - case OPCODE_DEFAULT: return "default"; - case OPCODE_DERIV_RTX: return "deriv_rtx"; - case OPCODE_DERIV_RTY: return "deriv_rty"; - case OPCODE_DISCARD: return "discard"; - case OPCODE_DIV: return "div"; - case OPCODE_DP2: return "dp2"; - case OPCODE_DP3: return "dp3"; - case OPCODE_DP4: return "dp4"; - case OPCODE_ELSE: return "else"; - case OPCODE_EMIT: return "emit"; - case OPCODE_EMITTHENCUT: return "emitthencut"; - case OPCODE_ENDIF: return "endif"; - case OPCODE_ENDLOOP: return "endloop"; - case OPCODE_ENDSWITCH: return "endswitch"; - case OPCODE_EQ: return "eq"; - case OPCODE_EXP: return "exp"; - case OPCODE_FRC: return "frc"; - case OPCODE_FTOI: return "ftoi"; - case OPCODE_FTOU: return "ftou"; - case OPCODE_GE: return "ge"; - case OPCODE_IADD: return "iadd"; - case OPCODE_IF: return "if"; - case OPCODE_IEQ: return "ieq"; - case OPCODE_IGE: return "ige"; - case OPCODE_ILT: return "ilt"; - case OPCODE_IMAD: return "imad"; - case OPCODE_IMAX: return "imax"; - case OPCODE_IMIN: return "imin"; - case OPCODE_IMUL: return "imul"; - case OPCODE_INE: return "ine"; - case OPCODE_INEG: return "ineg"; - case OPCODE_ISHL: return "ishl"; - case OPCODE_ISHR: return "ishr"; - case OPCODE_ITOF: return "itof"; - case OPCODE_LABEL: return "label"; - case OPCODE_LD: return "ld_indexable"; - case OPCODE_LD_MS: return "ld_ms"; - case OPCODE_LOG: return "log"; - case OPCODE_LOOP: return "loop"; - case OPCODE_LT: return "lt"; - case OPCODE_MAD: return "mad"; - case OPCODE_MIN: return "min"; - case OPCODE_MAX: return "max"; - case OPCODE_CUSTOMDATA: return "customdata"; - case OPCODE_MOV: return "mov"; - case OPCODE_MOVC: return "movc"; - case OPCODE_MUL: return "mul"; - case OPCODE_NE: return "ne"; - case OPCODE_NOP: return "nop"; - case OPCODE_NOT: return "not"; - case OPCODE_OR: return "or"; - case OPCODE_RESINFO: return "resinfo_indexable"; - case OPCODE_RET: return "ret"; - case OPCODE_RETC: return "retc"; - case OPCODE_ROUND_NE: return "round_ne"; - case OPCODE_ROUND_NI: return "round_ni"; - case OPCODE_ROUND_PI: return "round_pi"; - case OPCODE_ROUND_Z: return "round_z"; - case OPCODE_RSQ: return "rsq"; - case OPCODE_SAMPLE: return "sample_indexable"; - case OPCODE_SAMPLE_C: return "sample_c"; - case OPCODE_SAMPLE_C_LZ: return "sample_c_lz"; - case OPCODE_SAMPLE_L: return "sample_l"; - case OPCODE_SAMPLE_D: return "sample_d"; - case OPCODE_SAMPLE_B: return "sample_b"; - case OPCODE_SQRT: return "sqrt"; - case OPCODE_SWITCH: return "switch"; - case OPCODE_SINCOS: return "sincos"; - case OPCODE_UDIV: return "udiv"; - case OPCODE_ULT: return "ult"; - case OPCODE_UGE: return "uge"; - case OPCODE_UMUL: return "umul"; - case OPCODE_UMAD: return "umad"; - case OPCODE_UMAX: return "umax"; - case OPCODE_UMIN: return "umin"; - case OPCODE_USHR: return "ushr"; - case OPCODE_UTOF: return "utof"; - case OPCODE_XOR: return "xor"; - case OPCODE_DCL_RESOURCE: return "dcl_resource"; - case OPCODE_DCL_CONSTANT_BUFFER: return "dcl_constantbuffer"; - case OPCODE_DCL_SAMPLER: return "dcl_sampler"; - case OPCODE_DCL_INDEX_RANGE: return "dcl_indexRange"; - case OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY: return "dcl_outputtopology"; - case OPCODE_DCL_GS_INPUT_PRIMITIVE: return "dcl_inputprimitive"; - case OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT: return "dcl_maxout"; - case OPCODE_DCL_INPUT: return "dcl_input"; - case OPCODE_DCL_INPUT_SGV: return "dcl_input_sgv"; - case OPCODE_DCL_INPUT_SIV: return "dcl_input_siv"; - case OPCODE_DCL_INPUT_PS: return "dcl_input_ps"; - case OPCODE_DCL_INPUT_PS_SGV: return "dcl_input_ps_sgv"; - case OPCODE_DCL_INPUT_PS_SIV: return "dcl_input_ps_siv"; - case OPCODE_DCL_OUTPUT: return "dcl_output"; - case OPCODE_DCL_OUTPUT_SGV: return "dcl_output_sgv"; - case OPCODE_DCL_OUTPUT_SIV: return "dcl_output_siv"; - case OPCODE_DCL_TEMPS: return "dcl_temps"; - case OPCODE_DCL_INDEXABLE_TEMP: return "dcl_indexableTemp"; - case OPCODE_DCL_GLOBAL_FLAGS: return "dcl_globalFlags"; - case OPCODE_LOD: return "lod"; - case OPCODE_GATHER4: return "gather4"; - case OPCODE_SAMPLE_POS: return "samplepos"; - case OPCODE_SAMPLE_INFO: return "sample_info"; - case OPCODE_HS_DECLS: return "hs_decls"; - case OPCODE_HS_CONTROL_POINT_PHASE: return "hs_control_point_phase"; - case OPCODE_HS_FORK_PHASE: return "hs_fork_phase"; - case OPCODE_HS_JOIN_PHASE: return "hs_join_phase"; - case OPCODE_EMIT_STREAM: return "emit_stream"; - case OPCODE_CUT_STREAM: return "cut_stream"; - case OPCODE_EMITTHENCUT_STREAM: return "emitThenCut_stream"; - case OPCODE_INTERFACE_CALL: return "fcall"; - case OPCODE_BUFINFO: return "bufinfo"; - case OPCODE_DERIV_RTX_COARSE: return "deriv_rtx_coarse"; - case OPCODE_DERIV_RTX_FINE: return "deriv_rtx_fine"; - case OPCODE_DERIV_RTY_COARSE: return "deriv_rty_coarse"; - case OPCODE_DERIV_RTY_FINE: return "deriv_rty_fine"; - case OPCODE_GATHER4_C: return "gather4_c"; - case OPCODE_GATHER4_PO: return "gather4_po"; - case OPCODE_GATHER4_PO_C: return "gather4_po_c"; - case OPCODE_RCP: return "rcp"; - case OPCODE_F32TOF16: return "f32tof16"; - case OPCODE_F16TOF32: return "f16tof32"; - case OPCODE_UADDC: return "uaddc"; - case OPCODE_USUBB: return "usubb"; - case OPCODE_COUNTBITS: return "countbits"; - case OPCODE_FIRSTBIT_HI: return "firstbit_hi"; - case OPCODE_FIRSTBIT_LO: return "firstbit_lo"; - case OPCODE_FIRSTBIT_SHI: return "firstbit_shi"; - case OPCODE_UBFE: return "ubfe"; - case OPCODE_IBFE: return "ibfe"; - case OPCODE_BFI: return "bfi"; - case OPCODE_BFREV: return "bfrev"; - case OPCODE_SWAPC: return "swapc"; - case OPCODE_DCL_STREAM: return "dcl_stream"; - case OPCODE_DCL_FUNCTION_BODY: return "dcl_function_body"; - case OPCODE_DCL_FUNCTION_TABLE: return "dcl_function_table"; - case OPCODE_DCL_INTERFACE: return "dcl_interface"; - case OPCODE_DCL_INPUT_CONTROL_POINT_COUNT: return "dcl_input_control_point_count"; - case OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT: return "dcl_output_control_point_count"; - case OPCODE_DCL_TESS_DOMAIN: return "dcl_tessellator_domain"; - case OPCODE_DCL_TESS_PARTITIONING: return "dcl_tessellator_partitioning"; - case OPCODE_DCL_TESS_OUTPUT_PRIMITIVE: return "dcl_tessellator_output_primitive"; - case OPCODE_DCL_HS_MAX_TESSFACTOR: return "dcl_hs_max_tessfactor"; - case OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT: return "dcl_hs_fork_phase_instance_count"; - case OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT: return "dcl_hs_join_phase_instance_count"; - case OPCODE_DCL_THREAD_GROUP: return "dcl_thread_group"; - case OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED: return "dcl_uav_typed"; - case OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW: return "dcl_uav_raw"; - case OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED: return "dcl_uav_structured"; - case OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW: return "dcl_tgsm_raw"; - case OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED: return "dcl_tgsm_structured"; - case OPCODE_DCL_RESOURCE_RAW: return "dcl_resource_raw"; - case OPCODE_DCL_RESOURCE_STRUCTURED: return "dcl_resource_structured"; - case OPCODE_LD_UAV_TYPED: return "ld_uav_typed"; - case OPCODE_STORE_UAV_TYPED: return "store_uav_typed"; - case OPCODE_LD_RAW: return "ld_raw"; - case OPCODE_STORE_RAW: return "store_raw"; - case OPCODE_LD_STRUCTURED: return "ld_structured"; - case OPCODE_STORE_STRUCTURED: return "store_structured"; - case OPCODE_ATOMIC_AND: return "atomic_and"; - case OPCODE_ATOMIC_OR: return "atomic_or"; - case OPCODE_ATOMIC_XOR: return "atomic_xor"; - case OPCODE_ATOMIC_CMP_STORE: return "atomic_cmp_store"; - case OPCODE_ATOMIC_IADD: return "atomic_iadd"; - case OPCODE_ATOMIC_IMAX: return "atomic_imax"; - case OPCODE_ATOMIC_IMIN: return "atomic_imin"; - case OPCODE_ATOMIC_UMAX: return "atomic_umax"; - case OPCODE_ATOMIC_UMIN: return "atomic_umin"; - case OPCODE_IMM_ATOMIC_ALLOC: return "imm_atomic_alloc"; - case OPCODE_IMM_ATOMIC_CONSUME: return "imm_atomic_consume"; - case OPCODE_IMM_ATOMIC_IADD: return "imm_atomic_iadd"; - case OPCODE_IMM_ATOMIC_AND: return "imm_atomic_and"; - case OPCODE_IMM_ATOMIC_OR: return "imm_atomic_or"; - case OPCODE_IMM_ATOMIC_XOR: return "imm_atomic_xor"; - case OPCODE_IMM_ATOMIC_EXCH: return "imm_atomic_exch"; - case OPCODE_IMM_ATOMIC_CMP_EXCH: return "imm_atomic_cmp_exch"; - case OPCODE_IMM_ATOMIC_IMAX: return "imm_atomic_imax"; - case OPCODE_IMM_ATOMIC_IMIN: return "imm_atomic_imin"; - case OPCODE_IMM_ATOMIC_UMAX: return "imm_atomic_umax"; - case OPCODE_IMM_ATOMIC_UMIN: return "imm_atomic_umin"; - case OPCODE_SYNC: return "sync"; - case OPCODE_DADD: return "dadd"; - case OPCODE_DMAX: return "dmax"; - case OPCODE_DMIN: return "dmin"; - case OPCODE_DMUL: return "dmul"; - case OPCODE_DEQ: return "deq"; - case OPCODE_DGE: return "dge"; - case OPCODE_DLT: return "dlt"; - case OPCODE_DNE: return "dne"; - case OPCODE_DMOV: return "dmov"; - case OPCODE_DMOVC: return "dmovc"; - case OPCODE_DTOF: return "dtof"; - case OPCODE_FTOD: return "ftod"; - case OPCODE_EVAL_SNAPPED: return "eval_snapped"; - case OPCODE_EVAL_SAMPLE_INDEX: return "eval_sample_index"; - case OPCODE_EVAL_CENTROID: return "eval_centroid"; - case OPCODE_DCL_GS_INSTANCE_COUNT: return "dcl_gs_instance_count"; - case OPCODE_ABORT: return "abort"; - case OPCODE_DEBUGBREAK: return "debugbreak"; - - case OPCODE_DDIV: return "ddiv"; - case OPCODE_DFMA: return "dfma"; - case OPCODE_DRCP: return "drcp"; - - case OPCODE_MSAD: return "msad"; - - case OPCODE_DTOI: return "dtoi"; - case OPCODE_DTOU: return "dtou"; - case OPCODE_ITOD: return "itod"; - case OPCODE_UTOD: return "utod"; - - case OPCODE_GATHER4_FEEDBACK: return "gather4_statusk"; - case OPCODE_GATHER4_C_FEEDBACK: return "gather4_c_status"; - case OPCODE_GATHER4_PO_FEEDBACK: return "gather4_po_statusk"; - case OPCODE_GATHER4_PO_C_FEEDBACK: return "gather4_po_c_status"; - case OPCODE_LD_FEEDBACK: return "ld"; - case OPCODE_LD_MS_FEEDBACK: return "ld_ms_status"; - case OPCODE_LD_UAV_TYPED_FEEDBACK: return "ld_uav_typed_status"; - case OPCODE_LD_RAW_FEEDBACK: return "ld_raw_status"; - case OPCODE_LD_STRUCTURED_FEEDBACK: return "ld_structured_status"; - case OPCODE_SAMPLE_L_FEEDBACK: return "sample_l_status"; - case OPCODE_SAMPLE_C_LZ_FEEDBACK: return "sample_c_lz_status"; - - case OPCODE_SAMPLE_CLAMP_FEEDBACK: return "sample_status"; - case OPCODE_SAMPLE_B_CLAMP_FEEDBACK: return "sample_b_status"; - case OPCODE_SAMPLE_D_CLAMP_FEEDBACK: return "sample_d_status"; - case OPCODE_SAMPLE_C_CLAMP_FEEDBACK: return "sample_c_status"; - - case OPCODE_CHECK_ACCESS_FULLY_MAPPED: return "check_access_fully_mapped"; - - default: break; - } - - RDCERR("Unknown opcode: %u", op); - return ""; -} - -char *toString(ResourceDimension dim) -{ - switch(dim) - { - case RESOURCE_DIMENSION_UNKNOWN: return "unknown"; - case RESOURCE_DIMENSION_BUFFER: return "buffer"; - case RESOURCE_DIMENSION_TEXTURE1D: return "texture1d"; - case RESOURCE_DIMENSION_TEXTURE2D: return "texture2d"; - case RESOURCE_DIMENSION_TEXTURE2DMS: return "texture2dms"; - case RESOURCE_DIMENSION_TEXTURE3D: return "texture3d"; - case RESOURCE_DIMENSION_TEXTURECUBE: return "texturecube"; - case RESOURCE_DIMENSION_TEXTURE1DARRAY: return "texture1darray"; - case RESOURCE_DIMENSION_TEXTURE2DARRAY: return "texture2darray"; - case RESOURCE_DIMENSION_TEXTURE2DMSARRAY: return "texture2dmsarray"; - case RESOURCE_DIMENSION_TEXTURECUBEARRAY: return "texturecubearray"; - case RESOURCE_DIMENSION_RAW_BUFFER: return "rawbuffer"; - case RESOURCE_DIMENSION_STRUCTURED_BUFFER: return "structured_buffer"; - default: break; - } - - RDCERR("Unknown dim: %u", dim); - return ""; -} - -char *toString(DXBC::ResourceRetType type) -{ - switch(type) - { - case DXBC::RETURN_TYPE_UNORM: return "unorm"; - case DXBC::RETURN_TYPE_SNORM: return "snorm"; - case DXBC::RETURN_TYPE_SINT: return "sint"; - case DXBC::RETURN_TYPE_UINT: return "uint"; - case DXBC::RETURN_TYPE_FLOAT: return "float"; - case DXBC::RETURN_TYPE_MIXED: return "mixed"; - case DXBC::RETURN_TYPE_DOUBLE: return "double"; - case DXBC::RETURN_TYPE_CONTINUED: return "continued"; - case DXBC::RETURN_TYPE_UNUSED: return "unused"; - default: break; - } - - RDCERR("Unknown type: %u", type); - return ""; -} - -char *toString(ResinfoRetType type) -{ - switch(type) - { - case RETTYPE_FLOAT: return "float"; - case RETTYPE_RCPFLOAT: return "rcpfloat"; - case RETTYPE_UINT: return "uint"; - default: break; - } - - RDCERR("Unknown type: %u", type); - return ""; -} - -char *toString(InterpolationMode interp) -{ - switch(interp) - { - case INTERPOLATION_UNDEFINED: return "undefined"; - case INTERPOLATION_CONSTANT: return "constant"; - case INTERPOLATION_LINEAR: return "linear"; - case INTERPOLATION_LINEAR_CENTROID: return "linearCentroid"; - case INTERPOLATION_LINEAR_NOPERSPECTIVE: return "linearNopersp"; - case INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID: return "linearNoperspCentroid"; - case INTERPOLATION_LINEAR_SAMPLE: return "linearSample"; - case INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE: return "linaerNoperspSample"; - default: break; - } - - RDCERR("Unknown interp: %u", interp); - return ""; -} - -char *SystemValueToString(DXBC::SVSemantic name) -{ - switch(name) - { - case DXBC::SVNAME_POSITION: return "position"; - case DXBC::SVNAME_CLIP_DISTANCE: return "clipdistance"; - case DXBC::SVNAME_CULL_DISTANCE: return "culldistance"; - case DXBC::SVNAME_RENDER_TARGET_ARRAY_INDEX: return "rendertarget_array_index"; - case DXBC::SVNAME_VIEWPORT_ARRAY_INDEX: return "viewport_array_index"; - case DXBC::SVNAME_VERTEX_ID: return "vertexid"; - case DXBC::SVNAME_PRIMITIVE_ID: return "primitiveid"; - case DXBC::SVNAME_INSTANCE_ID: return "instanceid"; - case DXBC::SVNAME_IS_FRONT_FACE: return "isfrontface"; - case DXBC::SVNAME_SAMPLE_INDEX: - return "sampleidx"; - - // tessellation factors don't correspond directly to their enum values - - // SVNAME_FINAL_QUAD_EDGE_TESSFACTOR - case DXBC::SVNAME_FINAL_QUAD_EDGE_TESSFACTOR0: return "finalQuadUeq0EdgeTessFactor"; - case DXBC::SVNAME_FINAL_QUAD_EDGE_TESSFACTOR1: return "finalQuadVeq0EdgeTessFactor"; - case DXBC::SVNAME_FINAL_QUAD_EDGE_TESSFACTOR2: return "finalQuadUeq1EdgeTessFactor"; - case DXBC::SVNAME_FINAL_QUAD_EDGE_TESSFACTOR3: - return "finalQuadVeq1EdgeTessFactor"; - - // SVNAME_FINAL_QUAD_INSIDE_TESSFACTOR - case DXBC::SVNAME_FINAL_QUAD_INSIDE_TESSFACTOR0: return "finalQuadUInsideTessFactor"; - case DXBC::SVNAME_FINAL_QUAD_INSIDE_TESSFACTOR1: - return "finalQuadVInsideTessFactor"; - - // SVNAME_FINAL_TRI_EDGE_TESSFACTOR - case DXBC::SVNAME_FINAL_TRI_EDGE_TESSFACTOR0: return "finalTriUeq0EdgeTessFactor"; - case DXBC::SVNAME_FINAL_TRI_EDGE_TESSFACTOR1: return "finalTriVeq0EdgeTessFactor"; - case DXBC::SVNAME_FINAL_TRI_EDGE_TESSFACTOR2: - return "finalTriWeq0EdgeTessFactor"; - - // SVNAME_FINAL_TRI_INSIDE_TESSFACTOR - case DXBC::SVNAME_FINAL_TRI_INSIDE_TESSFACTOR: - return "finalTriInsideTessFactor"; - - // SVNAME_FINAL_LINE_DETAIL_TESSFACTOR - case DXBC::SVNAME_FINAL_LINE_DETAIL_TESSFACTOR: - return "finalLineEdgeTessFactor"; - - // SVNAME_FINAL_LINE_DENSITY_TESSFACTOR - case DXBC::SVNAME_FINAL_LINE_DENSITY_TESSFACTOR: return "finalLineInsideTessFactor"; - - case DXBC::SVNAME_TARGET: return "target"; - case DXBC::SVNAME_DEPTH: return "depth"; - case DXBC::SVNAME_COVERAGE: return "coverage"; - case DXBC::SVNAME_DEPTH_GREATER_EQUAL: return "depthgreaterequal"; - case DXBC::SVNAME_DEPTH_LESS_EQUAL: return "depthlessequal"; - default: break; - } - - RDCERR("Unknown name: %u", name); - return ""; -} - -bool IsDeclaration(OpcodeType op) -{ - // isDecl means not a real instruction, just a declaration type token - bool isDecl = false; - isDecl = isDecl || (op >= OPCODE_DCL_RESOURCE && op <= OPCODE_DCL_GLOBAL_FLAGS); - isDecl = isDecl || (op >= OPCODE_DCL_STREAM && op <= OPCODE_DCL_RESOURCE_STRUCTURED); - isDecl = isDecl || (op == OPCODE_DCL_GS_INSTANCE_COUNT); - isDecl = isDecl || (op == OPCODE_HS_DECLS); - isDecl = isDecl || (op == OPCODE_CUSTOMDATA); - - return isDecl; -} - }; // namespace DXBCBytecode + +template <> +rdcstr DoStringise(const DXBCBytecode::OpcodeType &el) +{ + BEGIN_ENUM_STRINGISE(DXBCBytecode::OpcodeType) + { + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ADD, "add") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_AND, "and") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_BREAK, "break") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_BREAKC, "breakc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CALL, "call") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CALLC, "callc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CASE, "case") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CONTINUE, "continue") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CONTINUEC, "continuec") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CUT, "cut") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DEFAULT, "default") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DERIV_RTX, "deriv_rtx") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DERIV_RTY, "deriv_rty") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DISCARD, "discard") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DIV, "div") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DP2, "dp2") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DP3, "dp3") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DP4, "dp4") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ELSE, "else") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EMIT, "emit") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EMITTHENCUT, "emitthencut") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ENDIF, "endif") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ENDLOOP, "endloop") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ENDSWITCH, "endswitch") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EQ, "eq") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EXP, "exp") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FRC, "frc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FTOI, "ftoi") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FTOU, "ftou") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GE, "ge") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IADD, "iadd") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IF, "if") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IEQ, "ieq") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IGE, "ige") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ILT, "ilt") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMAD, "imad") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMAX, "imax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMIN, "imin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMUL, "imul") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_INE, "ine") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_INEG, "ineg") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ISHL, "ishl") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ISHR, "ishr") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ITOF, "itof") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LABEL, "label") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD, "ld_indexable") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_MS, "ld_ms") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LOG, "log") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LOOP, "loop") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LT, "lt") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MAD, "mad") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MIN, "min") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MAX, "max") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CUSTOMDATA, "customdata") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MOV, "mov") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MOVC, "movc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MUL, "mul") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_NE, "ne") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_NOP, "nop") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_NOT, "not") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_OR, "or") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_RESINFO, "resinfo_indexable") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_RET, "ret") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_RETC, "retc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ROUND_NE, "round_ne") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ROUND_NI, "round_ni") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ROUND_PI, "round_pi") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ROUND_Z, "round_z") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_RSQ, "rsq") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE, "sample_indexable") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_C, "sample_c") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_C_LZ, "sample_c_lz") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_L, "sample_l") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_D, "sample_d") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_B, "sample_b") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SQRT, "sqrt") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SWITCH, "switch") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SINCOS, "sincos") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UDIV, "udiv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ULT, "ult") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UGE, "uge") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UMUL, "umul") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UMAD, "umad") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UMAX, "umax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UMIN, "umin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_USHR, "ushr") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UTOF, "utof") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_XOR, "xor") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_RESOURCE, "dcl_resource") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_CONSTANT_BUFFER, "dcl_constantbuffer") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_SAMPLER, "dcl_sampler") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INDEX_RANGE, "dcl_indexRange") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY, "dcl_outputtopology") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_GS_INPUT_PRIMITIVE, "dcl_inputprimitive") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT, "dcl_maxout") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT, "dcl_input") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT_SGV, "dcl_input_sgv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT_SIV, "dcl_input_siv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT_PS, "dcl_input_ps") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT_PS_SGV, "dcl_input_ps_sgv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT_PS_SIV, "dcl_input_ps_siv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_OUTPUT, "dcl_output") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_OUTPUT_SGV, "dcl_output_sgv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_OUTPUT_SIV, "dcl_output_siv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_TEMPS, "dcl_temps") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INDEXABLE_TEMP, "dcl_indexableTemp") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_GLOBAL_FLAGS, "dcl_globalFlags") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LOD, "lod") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4, "gather4") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_POS, "samplepos") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_INFO, "sample_info") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_HS_DECLS, "hs_decls") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_HS_CONTROL_POINT_PHASE, "hs_control_point_phase") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_HS_FORK_PHASE, "hs_fork_phase") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_HS_JOIN_PHASE, "hs_join_phase") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EMIT_STREAM, "emit_stream") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CUT_STREAM, "cut_stream") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EMITTHENCUT_STREAM, "emitThenCut_stream") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_INTERFACE_CALL, "fcall") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_BUFINFO, "bufinfo") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DERIV_RTX_COARSE, "deriv_rtx_coarse") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DERIV_RTX_FINE, "deriv_rtx_fine") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DERIV_RTY_COARSE, "deriv_rty_coarse") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DERIV_RTY_FINE, "deriv_rty_fine") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_C, "gather4_c") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_PO, "gather4_po") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_PO_C, "gather4_po_c") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_RCP, "rcp") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_F32TOF16, "f32tof16") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_F16TOF32, "f16tof32") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UADDC, "uaddc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_USUBB, "usubb") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_COUNTBITS, "countbits") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FIRSTBIT_HI, "firstbit_hi") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FIRSTBIT_LO, "firstbit_lo") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FIRSTBIT_SHI, "firstbit_shi") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UBFE, "ubfe") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IBFE, "ibfe") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_BFI, "bfi") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_BFREV, "bfrev") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SWAPC, "swapc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_STREAM, "dcl_stream") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_FUNCTION_BODY, "dcl_function_body") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_FUNCTION_TABLE, "dcl_function_table") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INTERFACE, "dcl_interface") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_INPUT_CONTROL_POINT_COUNT, + "dcl_input_control_point_count") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT, + "dcl_output_control_point_count") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_TESS_DOMAIN, "dcl_tessellator_domain") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_TESS_PARTITIONING, "dcl_tessellator_partitioning") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_TESS_OUTPUT_PRIMITIVE, "dcl_tessellator_output_primitive") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_HS_MAX_TESSFACTOR, "dcl_hs_max_tessfactor") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT, + "dcl_hs_fork_phase_instance_count") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, + "dcl_hs_join_phase_instance_count") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_THREAD_GROUP, "dcl_thread_group") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED, "dcl_uav_typed") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW, "dcl_uav_raw") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED, "dcl_uav_structured") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW, "dcl_tgsm_raw") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED, + "dcl_tgsm_structured") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_RESOURCE_RAW, "dcl_resource_raw") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_RESOURCE_STRUCTURED, "dcl_resource_structured") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_UAV_TYPED, "ld_uav_typed") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_STORE_UAV_TYPED, "store_uav_typed") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_RAW, "ld_raw") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_STORE_RAW, "store_raw") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_STRUCTURED, "ld_structured") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_STORE_STRUCTURED, "store_structured") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_AND, "atomic_and") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_OR, "atomic_or") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_XOR, "atomic_xor") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_CMP_STORE, "atomic_cmp_store") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_IADD, "atomic_iadd") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_IMAX, "atomic_imax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_IMIN, "atomic_imin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_UMAX, "atomic_umax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ATOMIC_UMIN, "atomic_umin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_ALLOC, "imm_atomic_alloc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_CONSUME, "imm_atomic_consume") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_IADD, "imm_atomic_iadd") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_AND, "imm_atomic_and") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_OR, "imm_atomic_or") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_XOR, "imm_atomic_xor") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_EXCH, "imm_atomic_exch") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_CMP_EXCH, "imm_atomic_cmp_exch") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_IMAX, "imm_atomic_imax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_IMIN, "imm_atomic_imin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_UMAX, "imm_atomic_umax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_IMM_ATOMIC_UMIN, "imm_atomic_umin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SYNC, "sync") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DADD, "dadd") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DMAX, "dmax") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DMIN, "dmin") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DMUL, "dmul") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DEQ, "deq") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DGE, "dge") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DLT, "dlt") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DNE, "dne") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DMOV, "dmov") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DMOVC, "dmovc") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DTOF, "dtof") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_FTOD, "ftod") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EVAL_SNAPPED, "eval_snapped") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EVAL_SAMPLE_INDEX, "eval_sample_index") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_EVAL_CENTROID, "eval_centroid") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DCL_GS_INSTANCE_COUNT, "dcl_gs_instance_count") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ABORT, "abort") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DEBUGBREAK, "debugbreak") + + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DDIV, "ddiv") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DFMA, "dfma") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DRCP, "drcp") + + STRINGISE_ENUM_CLASS_NAMED(OPCODE_MSAD, "msad") + + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DTOI, "dtoi") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_DTOU, "dtou") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_ITOD, "itod") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_UTOD, "utod") + + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_FEEDBACK, "gather4_statusk") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_C_FEEDBACK, "gather4_c_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_PO_FEEDBACK, "gather4_po_statusk") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_GATHER4_PO_C_FEEDBACK, "gather4_po_c_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_FEEDBACK, "ld") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_MS_FEEDBACK, "ld_ms_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_UAV_TYPED_FEEDBACK, "ld_uav_typed_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_RAW_FEEDBACK, "ld_raw_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_LD_STRUCTURED_FEEDBACK, "ld_structured_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_L_FEEDBACK, "sample_l_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_C_LZ_FEEDBACK, "sample_c_lz_status") + + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_CLAMP_FEEDBACK, "sample_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_B_CLAMP_FEEDBACK, "sample_b_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_D_CLAMP_FEEDBACK, "sample_d_status") + STRINGISE_ENUM_CLASS_NAMED(OPCODE_SAMPLE_C_CLAMP_FEEDBACK, "sample_c_status") + + STRINGISE_ENUM_CLASS_NAMED(OPCODE_CHECK_ACCESS_FULLY_MAPPED, "check_access_fully_mapped") + } + END_ENUM_STRINGISE(); +} +template <> +rdcstr DoStringise(const DXBCBytecode::OperandType &el) +{ + BEGIN_ENUM_STRINGISE(DXBCBytecode::OperandType) + { + STRINGISE_ENUM_CLASS_NAMED(TYPE_TEMP, "TEMP"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT, "INPUT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT, "OUTPUT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INDEXABLE_TEMP, "INDEXABLE_TEMP"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_IMMEDIATE32, "IMMEDIATE32"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_IMMEDIATE64, "IMMEDIATE64"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_SAMPLER, "SAMPLER"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_RESOURCE, "RESOURCE"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_CONSTANT_BUFFER, "CONSTANT_BUFFER"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_IMMEDIATE_CONSTANT_BUFFER, "IMMEDIATE_CONSTANT_BUFFER"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_LABEL, "LABEL"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_PRIMITIVEID, "INPUT_PRIMITIVEID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_DEPTH, "OUTPUT_DEPTH"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_NULL, "NULL"); + + STRINGISE_ENUM_CLASS_NAMED(TYPE_RASTERIZER, "RASTERIZER"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_COVERAGE_MASK, "OUTPUT_COVERAGE_MASK"); + + STRINGISE_ENUM_CLASS_NAMED(TYPE_STREAM, "STREAM"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_FUNCTION_BODY, "FUNCTION_BODY"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_FUNCTION_TABLE, "FUNCTION_TABLE"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INTERFACE, "INTERFACE"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_FUNCTION_INPUT, "FUNCTION_INPUT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_FUNCTION_OUTPUT, "FUNCTION_OUTPUT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_CONTROL_POINT_ID, "OUTPUT_CONTROL_POINT_ID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_FORK_INSTANCE_ID, "INPUT_FORK_INSTANCE_ID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_JOIN_INSTANCE_ID, "INPUT_JOIN_INSTANCE_ID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_CONTROL_POINT, "INPUT_CONTROL_POINT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_CONTROL_POINT, "OUTPUT_CONTROL_POINT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_PATCH_CONSTANT, "INPUT_PATCH_CONSTANT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_DOMAIN_POINT, "INPUT_DOMAIN_POINT"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_THIS_POINTER, "THIS_POINTER"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_UNORDERED_ACCESS_VIEW, "UNORDERED_ACCESS_VIEW"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_THREAD_GROUP_SHARED_MEMORY, "THREAD_GROUP_SHARED_MEMORY"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_THREAD_ID, "INPUT_THREAD_ID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_THREAD_GROUP_ID, "INPUT_THREAD_GROUP_ID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_THREAD_ID_IN_GROUP, "INPUT_THREAD_ID_IN_GROUP"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_COVERAGE_MASK, "INPUT_COVERAGE_MASK"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED, + "INPUT_THREAD_ID_IN_GROUP_FLATTENED"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INPUT_GS_INSTANCE_ID, "INPUT_GS_INSTANCE_ID"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_DEPTH_GREATER_EQUAL, "OUTPUT_DEPTH_GREATER_EQUAL"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_DEPTH_LESS_EQUAL, "OUTPUT_DEPTH_LESS_EQUAL"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_CYCLE_COUNTER, "CYCLE_COUNTER"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_OUTPUT_STENCIL_REF, "OUTPUT_STENCIL_REF"); + STRINGISE_ENUM_CLASS_NAMED(TYPE_INNER_COVERAGE, "INNER_COVERAGE"); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const DXBCBytecode::ResourceDimension &el) +{ + BEGIN_ENUM_STRINGISE(DXBCBytecode::ResourceDimension) + { + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_UNKNOWN, "unknown"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_BUFFER, "buffer"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE1D, "texture1d"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE2D, "texture2d"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE2DMS, "texture2dms"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE3D, "texture3d"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURECUBE, "texturecube"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE1DARRAY, "texture1darray"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE2DARRAY, "texture2darray"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURE2DMSARRAY, "texture2dmsarray"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_TEXTURECUBEARRAY, "texturecubearray"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_RAW_BUFFER, "rawbuffer"); + STRINGISE_ENUM_CLASS_NAMED(RESOURCE_DIMENSION_STRUCTURED_BUFFER, "structured_buffer"); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const DXBC::ResourceRetType &el) +{ + BEGIN_ENUM_STRINGISE(DXBC::ResourceRetType) + { + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_UNORM, "unorm"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_SNORM, "snorm"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_SINT, "sint"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_UINT, "uint"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_FLOAT, "float"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_MIXED, "mixed"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_DOUBLE, "double"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_CONTINUED, "continued"); + STRINGISE_ENUM_CLASS_NAMED(RETURN_TYPE_UNUSED, "unused"); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const DXBCBytecode::ResinfoRetType &el) +{ + BEGIN_ENUM_STRINGISE(DXBCBytecode::ResinfoRetType) + { + STRINGISE_ENUM_CLASS_NAMED(RETTYPE_FLOAT, "float"); + STRINGISE_ENUM_CLASS_NAMED(RETTYPE_RCPFLOAT, "rcpfloat"); + STRINGISE_ENUM_CLASS_NAMED(RETTYPE_UINT, "uint"); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const DXBCBytecode::InterpolationMode &el) +{ + BEGIN_ENUM_STRINGISE(DXBCBytecode::InterpolationMode) + { + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_UNDEFINED, "undefined"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_CONSTANT, "constant"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_LINEAR, "linear"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_LINEAR_CENTROID, "linearCentroid"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_LINEAR_NOPERSPECTIVE, "linearNopersp"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID, + "linearNoperspCentroid"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_LINEAR_SAMPLE, "linearSample"); + STRINGISE_ENUM_CLASS_NAMED(INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE, "linaerNoperspSample"); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const DXBC::SVSemantic &el) +{ + BEGIN_ENUM_STRINGISE(DXBC::SVSemantic) + { + STRINGISE_ENUM_CLASS_NAMED(SVNAME_POSITION, "position"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_CLIP_DISTANCE, "clipdistance"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_CULL_DISTANCE, "culldistance"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_RENDER_TARGET_ARRAY_INDEX, "rendertarget_array_index"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_VIEWPORT_ARRAY_INDEX, "viewport_array_index"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_VERTEX_ID, "vertexid"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_PRIMITIVE_ID, "primitiveid"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_INSTANCE_ID, "instanceid"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_IS_FRONT_FACE, "isfrontface"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_SAMPLE_INDEX, "sampleidx"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_QUAD_EDGE_TESSFACTOR0, "finalQuadUeq0EdgeTessFactor"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_QUAD_EDGE_TESSFACTOR1, "finalQuadVeq0EdgeTessFactor"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_QUAD_EDGE_TESSFACTOR2, "finalQuadUeq1EdgeTessFactor"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_QUAD_EDGE_TESSFACTOR3, "finalQuadVeq1EdgeTessFactor"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_QUAD_INSIDE_TESSFACTOR0, "finalQuadUInsideTessFactor"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_QUAD_INSIDE_TESSFACTOR1, "finalQuadVInsideTessFactor"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_TRI_EDGE_TESSFACTOR0, "finalTriUeq0EdgeTessFactor"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_TRI_EDGE_TESSFACTOR1, "finalTriVeq0EdgeTessFactor"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_TRI_EDGE_TESSFACTOR2, "finalTriWeq0EdgeTessFactor"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_TRI_INSIDE_TESSFACTOR, "finalTriInsideTessFactor"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_LINE_DETAIL_TESSFACTOR, "finalLineEdgeTessFactor"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_FINAL_LINE_DENSITY_TESSFACTOR, "finalLineInsideTessFactor"); + + STRINGISE_ENUM_CLASS_NAMED(SVNAME_TARGET, "target"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_DEPTH, "depth"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_COVERAGE, "coverage"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_DEPTH_GREATER_EQUAL, "depthgreaterequal"); + STRINGISE_ENUM_CLASS_NAMED(SVNAME_DEPTH_LESS_EQUAL, "depthlessequal"); + } + END_ENUM_STRINGISE(); +}