diff --git a/renderdoc/driver/d3d12/d3d12_postvs.cpp b/renderdoc/driver/d3d12/d3d12_postvs.cpp index fac5f2acd..f69ecd07b 100644 --- a/renderdoc/driver/d3d12/d3d12_postvs.cpp +++ b/renderdoc/driver/d3d12/d3d12_postvs.cpp @@ -120,7 +120,7 @@ static void PayloadBufferCopy(PayloadCopyDir dir, DXIL::ProgramEditor &editor, D Instruction *srcRet = editor.InsertInstruction( f, curInst++, - editor.CreateInstruction(loadBuf, DXOp::rawBufferLoad, + editor.CreateInstruction(loadBuf, DXOp::RawBufferLoad, {handle, offset, editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), align})); @@ -156,7 +156,7 @@ static void PayloadBufferCopy(PayloadCopyDir dir, DXIL::ProgramEditor &editor, D editor.InsertInstruction( f, curInst++, editor.CreateInstruction( - storeBuf, DXOp::rawBufferStore, + storeBuf, DXOp::RawBufferStore, {handle, offset, editor.CreateUndef(i32), load, editor.CreateUndef(memberType), editor.CreateUndef(memberType), editor.CreateUndef(memberType), editor.CreateConstant((uint8_t)0x1), align})); @@ -450,7 +450,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 RDCASSERT(!isShaderModel6_6OrAbove); handle = editor.InsertInstruction( f, prelimInst++, - editor.CreateInstruction(createHandle, DXOp::createHandle, + editor.CreateInstruction(createHandle, DXOp::CreateHandle, { // kind = UAV editor.CreateConstant((uint8_t)HandleKind::UAV), @@ -480,7 +480,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 Instruction *unannotatedHandle = editor.InsertInstruction( f, prelimInst++, - editor.CreateInstruction(createHandleFromBinding, DXOp::createHandleFromBinding, + editor.CreateInstruction(createHandleFromBinding, DXOp::CreateHandleFromBinding, { // resBind resBindConstant, @@ -500,7 +500,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 }); handle = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(annotateHandle, DXOp::annotateHandle, + editor.CreateInstruction(annotateHandle, DXOp::AnnotateHandle, { // Resource handle unannotatedHandle, @@ -523,17 +523,17 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 { // get our output location from group ID groupX = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(groupId, DXOp::groupId, {i32_0})); + editor.CreateInstruction(groupId, DXOp::GroupId, {i32_0})); groupY = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(groupId, DXOp::groupId, {i32_1})); + editor.CreateInstruction(groupId, DXOp::GroupId, {i32_1})); groupZ = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(groupId, DXOp::groupId, {i32_2})); + editor.CreateInstruction(groupId, DXOp::GroupId, {i32_2})); } // get the flat thread ID for comparisons Instruction *flatId = editor.InsertInstruction( f, prelimInst++, - editor.CreateInstruction(flattenedThreadIdInGroup, DXOp::flattenedThreadIdInGroup, {})); + editor.CreateInstruction(flattenedThreadIdInGroup, DXOp::FlattenedThreadIdInGroup, {})); Value *dimX = editor.CreateConstant(dispatchDim[0]); Value *dimY = editor.CreateConstant(dispatchDim[1]); @@ -615,7 +615,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 editor.InsertInstruction( f, i++, - editor.CreateInstruction(barrier, DXOp::barrier, + editor.CreateInstruction(barrier, DXOp::Barrier, { // barrier & TGSM sync editor.CreateConstant(uint32_t(0x1 | 0x8)), @@ -629,7 +629,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, xOffset, editor.CreateUndef(i32), inst.args[1], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), align})); @@ -641,7 +641,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, yOffset, editor.CreateUndef(i32), inst.args[2], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), align})); @@ -653,7 +653,7 @@ static void AddDXILAmpShaderPayloadStores(const DXBC::DXBCContainer *dxbc, uint3 editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, zOffset, editor.CreateUndef(i32), inst.args[3], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), align})); @@ -958,7 +958,7 @@ static void ConvertToFixedDXILAmpFeeder(const DXBC::DXBCContainer *dxbc, uint32_ { RDCASSERT(!isShaderModel6_6OrAbove); handle = editor.AddInstruction( - f, editor.CreateInstruction(createHandle, DXOp::createHandle, + f, editor.CreateInstruction(createHandle, DXOp::CreateHandle, { // kind = UAV editor.CreateConstant((uint8_t)HandleKind::UAV), @@ -987,7 +987,7 @@ static void ConvertToFixedDXILAmpFeeder(const DXBC::DXBCContainer *dxbc, uint32_ }); Instruction *unannotatedHandle = editor.AddInstruction( - f, editor.CreateInstruction(createHandleFromBinding, DXOp::createHandleFromBinding, + f, editor.CreateInstruction(createHandleFromBinding, DXOp::CreateHandleFromBinding, { // resBind resBindConstant, @@ -1006,7 +1006,7 @@ static void ConvertToFixedDXILAmpFeeder(const DXBC::DXBCContainer *dxbc, uint32_ editor.CreateConstant(0U), }); - handle = editor.AddInstruction(f, editor.CreateInstruction(annotateHandle, DXOp::annotateHandle, + handle = editor.AddInstruction(f, editor.CreateInstruction(annotateHandle, DXOp::AnnotateHandle, { // Resource handle unannotatedHandle, @@ -1024,11 +1024,11 @@ static void ConvertToFixedDXILAmpFeeder(const DXBC::DXBCContainer *dxbc, uint32_ // get our output location from group ID Instruction *groupX = - editor.AddInstruction(f, editor.CreateInstruction(groupId, DXOp::groupId, {i32_0})); + editor.AddInstruction(f, editor.CreateInstruction(groupId, DXOp::GroupId, {i32_0})); Instruction *groupY = - editor.AddInstruction(f, editor.CreateInstruction(groupId, DXOp::groupId, {i32_1})); + editor.AddInstruction(f, editor.CreateInstruction(groupId, DXOp::GroupId, {i32_1})); Instruction *groupZ = - editor.AddInstruction(f, editor.CreateInstruction(groupId, DXOp::groupId, {i32_2})); + editor.AddInstruction(f, editor.CreateInstruction(groupId, DXOp::GroupId, {i32_2})); // linearise it based on the number of dispatches Instruction *groupYMul = editor.AddInstruction( @@ -1047,7 +1047,7 @@ static void ConvertToFixedDXILAmpFeeder(const DXBC::DXBCContainer *dxbc, uint32_ {flatIndex, editor.CreateConstant(payloadSize + 16)})); Instruction *dimAndOffset = editor.AddInstruction( - f, editor.CreateInstruction(rawBufferLoad, DXOp::rawBufferLoad, + f, editor.CreateInstruction(rawBufferLoad, DXOp::RawBufferLoad, {handle, baseOffset, editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0xf), i32_4})); @@ -1093,7 +1093,7 @@ static void ConvertToFixedDXILAmpFeeder(const DXBC::DXBCContainer *dxbc, uint32_ editor.AddInstruction(f, store); } - editor.AddInstruction(f, editor.CreateInstruction(dispatchMesh, DXOp::dispatchMesh, + editor.AddInstruction(f, editor.CreateInstruction(dispatchMesh, DXOp::DispatchMesh, {dimX, dimY, dimZ, payloadVariable})); editor.AddInstruction(f, editor.CreateInstruction(Operation::Ret, voidType, {})); } @@ -1504,7 +1504,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D RDCASSERT(!isShaderModel6_6OrAbove); handle = editor.InsertInstruction( f, prelimInst++, - editor.CreateInstruction(createHandle, DXOp::createHandle, + editor.CreateInstruction(createHandle, DXOp::CreateHandle, { // kind = UAV editor.CreateConstant((uint8_t)HandleKind::UAV), @@ -1534,7 +1534,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D Instruction *unannotatedHandle = editor.InsertInstruction( f, prelimInst++, - editor.CreateInstruction(createHandleFromBinding, DXOp::createHandleFromBinding, + editor.CreateInstruction(createHandleFromBinding, DXOp::CreateHandleFromBinding, { // resBind resBindConstant, @@ -1554,7 +1554,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D }); handle = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(annotateHandle, DXOp::annotateHandle, + editor.CreateInstruction(annotateHandle, DXOp::AnnotateHandle, { // Resource handle unannotatedHandle, @@ -1578,17 +1578,17 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D { // get our output location from group ID groupX = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(groupId, DXOp::groupId, {i32_0})); + editor.CreateInstruction(groupId, DXOp::GroupId, {i32_0})); groupY = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(groupId, DXOp::groupId, {i32_1})); + editor.CreateInstruction(groupId, DXOp::GroupId, {i32_1})); groupZ = editor.InsertInstruction(f, prelimInst++, - editor.CreateInstruction(groupId, DXOp::groupId, {i32_2})); + editor.CreateInstruction(groupId, DXOp::GroupId, {i32_2})); } // get the flat thread ID for comparisons Instruction *flatId = editor.InsertInstruction( f, prelimInst++, - editor.CreateInstruction(flattenedThreadIdInGroup, DXOp::flattenedThreadIdInGroup, {})); + editor.CreateInstruction(flattenedThreadIdInGroup, DXOp::FlattenedThreadIdInGroup, {})); Value *dimX = NULL, *dimY = NULL; Instruction *dispatchBaseMeshletIdx = NULL; @@ -1612,7 +1612,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D // if there wasn't one before (because we added the payload, or it was unused) we can just add our own if(!payloadLoad) payloadLoad = editor.InsertInstruction( - f, prelimInst++, editor.CreateInstruction(getMeshPayload, DXOp::getMeshPayload, {})); + f, prelimInst++, editor.CreateInstruction(getMeshPayload, DXOp::GetMeshPayload, {})); Type *i32ptr = editor.CreatePointerType(i32, Type::PointerAddrSpace::Default); @@ -1714,7 +1714,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), inst.args[1], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), i32_4})); @@ -1725,7 +1725,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), inst.args[2], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), i32_4})); @@ -1812,7 +1812,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), value, editor.CreateUndef(value->type), editor.CreateUndef(value->type), editor.CreateUndef(value->type), editor.CreateConstant((uint8_t)0x1), i32_4})); @@ -1895,7 +1895,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), value, editor.CreateUndef(value->type), editor.CreateUndef(value->type), editor.CreateUndef(value->type), editor.CreateConstant((uint8_t)0x1), i32_4})); @@ -1922,7 +1922,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), inst.args[2], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), i32_4})); @@ -1934,7 +1934,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), inst.args[3], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), i32_4})); @@ -1948,7 +1948,7 @@ static void AddDXILMeshShaderOutputStores(uint32_t ampPayloadSize, const DXBC::D editor.InsertInstruction( f, i++, editor.CreateInstruction( - rawBufferStore, DXOp::rawBufferStore, + rawBufferStore, DXOp::RawBufferStore, {handle, writeOffset, editor.CreateUndef(i32), inst.args[4], editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateUndef(i32), editor.CreateConstant((uint8_t)0x1), i32_4})); diff --git a/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp b/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp index 844114a30..e6e12760f 100644 --- a/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp +++ b/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp @@ -503,7 +503,7 @@ static bool AnnotateDXILShader(const DXBC::DXBCContainer *dxbc, uint32_t space, RDCASSERT(!isShaderModel6_6OrAbove); handle = editor.InsertInstruction( f, startInst++, - editor.CreateInstruction(createHandle, DXOp::createHandle, + editor.CreateInstruction(createHandle, DXOp::CreateHandle, { // kind = UAV editor.CreateConstant((uint8_t)HandleKind::UAV), @@ -533,7 +533,7 @@ static bool AnnotateDXILShader(const DXBC::DXBCContainer *dxbc, uint32_t space, Instruction *handleCreate = editor.InsertInstruction( f, startInst++, - editor.CreateInstruction(createHandleFromBinding, DXOp::createHandleFromBinding, + editor.CreateInstruction(createHandleFromBinding, DXOp::CreateHandleFromBinding, { // resBind resBindConstant, @@ -546,7 +546,7 @@ static bool AnnotateDXILShader(const DXBC::DXBCContainer *dxbc, uint32_t space, handle = editor.InsertInstruction( f, startInst++, editor.CreateInstruction( - annotateHandle, DXOp::annotateHandle, + annotateHandle, DXOp::AnnotateHandle, { // Resource handle handleCreate, @@ -566,7 +566,7 @@ static bool AnnotateDXILShader(const DXBC::DXBCContainer *dxbc, uint32_t space, // insert an OR to offset 0, just to indicate validity editor.InsertInstruction(f, startInst++, - editor.CreateInstruction(atomicBinOp, DXOp::atomicBinOp, + editor.CreateInstruction(atomicBinOp, DXOp::AtomicBinOp, { // feedback UAV handle handle, @@ -719,7 +719,7 @@ static bool AnnotateDXILShader(const DXBC::DXBCContainer *dxbc, uint32_t space, })); editor.InsertInstruction(f, i++, - editor.CreateInstruction(atomicBinOp, DXOp::atomicBinOp, + editor.CreateInstruction(atomicBinOp, DXOp::AtomicBinOp, { // feedback UAV handle handle, @@ -883,7 +883,7 @@ static bool AnnotateDXILShader(const DXBC::DXBCContainer *dxbc, uint32_t space, uint32_t stageMask = (uint32_t)MaskForStage(GetShaderStage(editor.GetShaderType())); feedbackValue |= (stageMask << magicFeedbackStageShift) & magicFeedbackStageMask; editor.InsertInstruction(f, i++, - editor.CreateInstruction(atomicBinOp, DXOp::atomicBinOp, + editor.CreateInstruction(atomicBinOp, DXOp::AtomicBinOp, { // feedback UAV handle handle, diff --git a/renderdoc/driver/shaders/dxil/dxil_bytecode.h b/renderdoc/driver/shaders/dxil/dxil_bytecode.h index dfc647464..83315c284 100644 --- a/renderdoc/driver/shaders/dxil/dxil_bytecode.h +++ b/renderdoc/driver/shaders/dxil/dxil_bytecode.h @@ -312,43 +312,264 @@ enum class Operation : uint8_t // added as needed, since names in docs/LLVM don't match neatly so there's no pre-made list enum class DXOp : uint32_t { - loadInput = 4, - storeInput = 5, + TempRegLoad = 0, + TempRegStore = 1, + MinPrecXRegLoad = 2, + MinPrecXRegStore = 3, + LoadInput = 4, + StoreOutput = 5, + FAbs = 6, + Saturate = 7, + IsNaN = 8, + IsInf = 9, + IsFinite = 10, + IsNormal = 11, + Cos = 12, + Sin = 13, + Tan = 14, + Acos = 15, + Asin = 16, + Atan = 17, + Hcos = 18, + Hsin = 19, + Htan = 20, + Exp = 21, + Frc = 22, + Log = 23, + Sqrt = 24, + Rsqrt = 25, + Round_ne = 26, + Round_ni = 27, + Round_pi = 28, + Round_z = 29, + Bfrev = 30, + Countbits = 31, + FirstbitLo = 32, + FirstbitHi = 33, + FirstbitSHi = 34, + FMax = 35, + FMin = 36, + IMax = 37, + IMin = 38, + UMax = 39, UMin = 40, - dot2 = 54, - dot3 = 55, - dot4 = 56, - createHandle = 57, - cbufferLoad = 59, - cbufferLoadLegacy = 59, - sample = 60, - sampleBias = 61, - sampleLevel = 62, - sampleGrad = 63, - sampleCmp = 64, - sampleCmpLevelZero = 65, - textureLoad = 66, - textureStore = 67, - bufferLoad = 68, - bufferStore = 69, - atomicBinOp = 78, - barrier = 80, - groupId = 94, - threadIdInGroup = 95, - flattenedThreadIdInGroup = 96, - rawBufferLoad = 139, - rawBufferStore = 140, - setMeshOutputCounts = 168, - emitIndices = 169, - getMeshPayload = 170, - storeVertexOutput = 171, - storePrimitiveOutput = 172, - dispatchMesh = 173, - annotateHandle = 216, - createHandleFromBinding = 217, - sampleCmpLevel = 224, - sampleCmpGrad = 254, - sampleCmpBias = 255, + IMul = 41, + UMul = 42, + UDiv = 43, + UAddc = 44, + USubb = 45, + FMad = 46, + Fma = 47, + IMad = 48, + UMad = 49, + Msad = 50, + Ibfe = 51, + Ubfe = 52, + Bfi = 53, + Dot2 = 54, + Dot3 = 55, + Dot4 = 56, + CreateHandle = 57, + CBufferLoad = 58, + CBufferLoadLegacy = 59, + Sample = 60, + SampleBias = 61, + SampleLevel = 62, + SampleGrad = 63, + SampleCmp = 64, + SampleCmpLevelZero = 65, + TextureLoad = 66, + TextureStore = 67, + BufferLoad = 68, + BufferStore = 69, + BufferUpdateCounter = 70, + CheckAccessFullyMapped = 71, + GetDimensions = 72, + TextureGather = 73, + TextureGatherCmp = 74, + Texture2DMSGetSamplePosition = 75, + RenderTargetGetSamplePosition = 76, + RenderTargetGetSampleCount = 77, + AtomicBinOp = 78, + AtomicCompareExchange = 79, + Barrier = 80, + CalculateLOD = 81, + Discard = 82, + DerivCoarseX = 83, + DerivCoarseY = 84, + DerivFineX = 85, + DerivFineY = 86, + EvalSnapped = 87, + EvalSampleIndex = 88, + EvalCentroid = 89, + SampleIndex = 90, + Coverage = 91, + InnerCoverage = 92, + ThreadId = 93, + GroupId = 94, + ThreadIdInGroup = 95, + FlattenedThreadIdInGroup = 96, + EmitStream = 97, + CutStream = 98, + EmitThenCutStream = 99, + GSInstanceID = 100, + MakeDouble = 101, + SplitDouble = 102, + LoadOutputControlPoint = 103, + LoadPatchConstant = 104, + DomainLocation = 105, + StorePatchConstant = 106, + OutputControlPointID = 107, + PrimitiveID = 108, + CycleCounterLegacy = 109, + WaveIsFirstLane = 110, + WaveGetLaneIndex = 111, + WaveGetLaneCount = 112, + WaveAnyTrue = 113, + WaveAllTrue = 114, + WaveActiveAllEqual = 115, + WaveActiveBallot = 116, + WaveReadLaneAt = 117, + WaveReadLaneFirst = 118, + WaveActiveOp = 119, + WaveActiveBit = 120, + WavePrefixOp = 121, + QuadReadLaneAt = 122, + QuadOp = 123, + BitcastI16toF16 = 124, + BitcastF16toI16 = 125, + BitcastI32toF32 = 126, + BitcastF32toI32 = 127, + BitcastI64toF64 = 128, + BitcastF64toI64 = 129, + LegacyF32ToF16 = 130, + LegacyF16ToF32 = 131, + LegacyDoubleToFloat = 132, + LegacyDoubleToSInt32 = 133, + LegacyDoubleToUInt32 = 134, + WaveAllBitCount = 135, + WavePrefixBitCount = 136, + AttributeAtVertex = 137, + ViewID = 138, + RawBufferLoad = 139, + RawBufferStore = 140, + InstanceID = 141, + InstanceIndex = 142, + HitKind = 143, + RayFlags = 144, + DispatchRaysIndex = 145, + DispatchRaysDimensions = 146, + WorldRayOrigin = 147, + WorldRayDirection = 148, + ObjectRayOrigin = 149, + ObjectRayDirection = 150, + ObjectToWorld = 151, + WorldToObject = 152, + RayTMin = 153, + RayTCurrent = 154, + IgnoreHit = 155, + AcceptHitAndEndSearch = 156, + TraceRay = 157, + ReportHit = 158, + CallShader = 159, + CreateHandleForLib = 160, + PrimitiveIndex = 161, + Dot2AddHalf = 162, + Dot4AddI8Packed = 163, + Dot4AddU8Packed = 164, + WaveMatch = 165, + WaveMultiPrefixOp = 166, + WaveMultiPrefixBitCount = 167, + SetMeshOutputCounts = 168, + EmitIndices = 169, + GetMeshPayload = 170, + StoreVertexOutput = 171, + StorePrimitiveOutput = 172, + DispatchMesh = 173, + WriteSamplerFeedback = 174, + WriteSamplerFeedbackBias = 175, + WriteSamplerFeedbackLevel = 176, + WriteSamplerFeedbackGrad = 177, + AllocateRayQuery = 178, + RayQuery_TraceRayInline = 179, + RayQuery_Proceed = 180, + RayQuery_Abort = 181, + RayQuery_CommitNonOpaqueTriangleHit = 182, + RayQuery_CommitProceduralPrimitiveHit = 183, + RayQuery_CommittedStatus = 184, + RayQuery_CandidateType = 185, + RayQuery_CandidateObjectToWorld3x4 = 186, + RayQuery_CandidateWorldToObject3x4 = 187, + RayQuery_CommittedObjectToWorld3x4 = 188, + RayQuery_CommittedWorldToObject3x4 = 189, + RayQuery_CandidateProceduralPrimitiveNonOpaque = 190, + RayQuery_CandidateTriangleFrontFace = 191, + RayQuery_CommittedTriangleFrontFace = 192, + RayQuery_CandidateTriangleBarycentrics = 193, + RayQuery_CommittedTriangleBarycentrics = 194, + RayQuery_RayFlags = 195, + RayQuery_WorldRayOrigin = 196, + RayQuery_WorldRayDirection = 197, + RayQuery_RayTMin = 198, + RayQuery_CandidateTriangleRayT = 199, + RayQuery_CommittedRayT = 200, + RayQuery_CandidateInstanceIndex = 201, + RayQuery_CandidateInstanceID = 202, + RayQuery_CandidateGeometryIndex = 203, + RayQuery_CandidatePrimitiveIndex = 204, + RayQuery_CandidateObjectRayOrigin = 205, + RayQuery_CandidateObjectRayDirection = 206, + RayQuery_CommittedInstanceIndex = 207, + RayQuery_CommittedInstanceID = 208, + RayQuery_CommittedGeometryIndex = 209, + RayQuery_CommittedPrimitiveIndex = 210, + RayQuery_CommittedObjectRayOrigin = 211, + RayQuery_CommittedObjectRayDirection = 212, + GeometryIndex = 213, + RayQuery_CandidateInstanceContributionToHitGroupIndex = 214, + RayQuery_CommittedInstanceContributionToHitGroupIndex = 215, + AnnotateHandle = 216, + CreateHandleFromBinding = 217, + CreateHandleFromHeap = 218, + Unpack4x8 = 219, + Pack4x8 = 220, + IsHelperLane = 221, + QuadVote = 222, + TextureGatherRaw = 223, + SampleCmpLevel = 224, + TextureStoreSample = 225, + WaveMatrix_Annotate = 226, + WaveMatrix_Depth = 227, + WaveMatrix_Fill = 228, + WaveMatrix_LoadRawBuf = 229, + WaveMatrix_LoadGroupShared = 230, + WaveMatrix_StoreRawBuf = 231, + WaveMatrix_StoreGroupShared = 232, + WaveMatrix_Multiply = 233, + WaveMatrix_MultiplyAccumulate = 234, + WaveMatrix_ScalarOp = 235, + WaveMatrix_SumAccumulate = 236, + WaveMatrix_Add = 237, + AllocateNodeOutputRecords = 238, + GetNodeRecordPtr = 239, + IncrementOutputCount = 240, + OutputComplete = 241, + GetInputRecordCount = 242, + FinishedCrossGroupSharing = 243, + BarrierByMemoryType = 244, + BarrierByMemoryHandle = 245, + BarrierByNodeRecordHandle = 246, + CreateNodeOutputHandle = 247, + IndexNodeHandle = 248, + AnnotateNodeHandle = 249, + CreateNodeInputRecordHandle = 250, + AnnotateNodeRecordHandle = 251, + NodeOutputIsValid = 252, + GetRemainingRecursionLevels = 253, + SampleCmpGrad = 254, + SampleCmpBias = 255, + StartVertexLocation = 256, + StartInstanceLocation = 257, }; enum class AtomicBinOpCode : uint32_t @@ -1412,9 +1633,13 @@ bool needsEscaping(const rdcstr &name); rdcstr escapeString(const rdcstr &str); rdcstr escapeStringIfNeeded(const rdcstr &name); +template +bool getival(const Value *v, T &out); + }; // namespace DXIL DECLARE_REFLECTION_ENUM(DXIL::Attribute); DECLARE_STRINGISE_TYPE(DXIL::InstructionFlags); DECLARE_STRINGISE_TYPE(DXIL::AtomicBinOpCode); DECLARE_STRINGISE_TYPE(DXIL::Operation); +DECLARE_STRINGISE_TYPE(DXIL::DXOp); diff --git a/renderdoc/driver/shaders/dxil/dxil_disassemble.cpp b/renderdoc/driver/shaders/dxil/dxil_disassemble.cpp index 18b97e0a5..10d07f478 100644 --- a/renderdoc/driver/shaders/dxil/dxil_disassemble.cpp +++ b/renderdoc/driver/shaders/dxil/dxil_disassemble.cpp @@ -2365,9 +2365,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::loadInput); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::LoadInput); rdcstr name; rdcstr rowStr; rdcstr componentStr; @@ -2406,9 +2406,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // StoreOutput(outputSigId,rowIndex,colIndex,value) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::storeInput); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::StoreOutput); rdcstr name; rdcstr rowStr; rdcstr componentStr; @@ -2448,9 +2448,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // CreateHandle(resourceClass,rangeId,index,nonUniformIndex) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::createHandle); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::CreateHandle); rdcstr handleStr(resultIdStr); rdcstr resName; @@ -2486,13 +2486,13 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) // CBufferLoad(handle,byteOffset,alignment) // CBufferLoadLegacy(handle,regIndex) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); bool loadLegacy = funcCallName.beginsWith("dx.op.cbufferLoadLegacy"); if(loadLegacy) - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::cbufferLoadLegacy); + RDCASSERTEQUAL(dxOpCode, DXOp::CBufferLoadLegacy); else - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::cbufferLoad); + RDCASSERTEQUAL(dxOpCode, DXOp::CBufferLoad); rdcstr handleStr = ArgToString(inst.args[1], false); const ResourceReference *resRef = GetResourceReference(handleStr); if(resRef) @@ -2521,9 +2521,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) // BufferLoad(srv,index,wot) // wot is unused showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::bufferLoad); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::BufferLoad); rdcstr handleStr = ArgToString(inst.args[1], false); const ResourceReference *resRef = GetResourceReference(handleStr); if(resRef) @@ -2540,9 +2540,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // RawBufferLoad(srv,index,elementOffset,mask,alignment) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::rawBufferLoad); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::RawBufferLoad); rdcstr handleStr = ArgToString(inst.args[1], false); const ResourceReference *resRef = GetResourceReference(handleStr); if(resRef) @@ -2582,17 +2582,17 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // BufferStore(uav,coord0,coord1,value0,value1,value2,value3,mask) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::bufferStore); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::BufferStore); } else { // RawBufferStore(uav,index,elementOffset,value0,value1,value2,value3,mask,alignment) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::rawBufferStore); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::RawBufferStore); } rdcstr handleStr = ArgToString(inst.args[1], false); @@ -2650,9 +2650,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // TextureLoad(srv,mipLevelOrSampleCount,coord0,coord1,coord2,offset0,offset1,offset2) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::textureLoad); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::TextureLoad); rdcstr handleStr = ArgToString(inst.args[1], false); const ResourceReference *resRef = GetResourceReference(handleStr); if(resRef) @@ -2726,9 +2726,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // TextureStore(srv,coord0,coord1,coord2,value0,value1,value2,value3,mask) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::textureStore); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::TextureStore); rdcstr handleStr = ArgToString(inst.args[1], false); const ResourceReference *resRef = GetResourceReference(handleStr); if(resRef) @@ -2779,17 +2779,13 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) // SampleCmpLevel(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,compareValue,lod) // SampleCmpGrad(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,compareValue,ddx0,ddx1,ddx2,ddy0,ddy1,ddy2,clamp) // SampleCmpBias(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,compareValue,bias,clamp) - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERT((dxopCode == (uint32_t)DXOp::sample) || - (dxopCode == (uint32_t)DXOp::sampleBias) || - (dxopCode == (uint32_t)DXOp::sampleLevel) || - (dxopCode == (uint32_t)DXOp::sampleGrad) || - (dxopCode == (uint32_t)DXOp::sampleCmp) || - (dxopCode == (uint32_t)DXOp::sampleCmpLevelZero) || - (dxopCode == (uint32_t)DXOp::sampleCmpLevel) || - (dxopCode == (uint32_t)DXOp::sampleCmpGrad) || - (dxopCode == (uint32_t)DXOp::sampleCmpBias)); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERT((dxOpCode == DXOp::Sample) || (dxOpCode == DXOp::SampleBias) || + (dxOpCode == DXOp::SampleLevel) || (dxOpCode == DXOp::SampleGrad) || + (dxOpCode == DXOp::SampleCmp) || (dxOpCode == DXOp::SampleCmpLevelZero) || + (dxOpCode == DXOp::SampleCmpLevel) || (dxOpCode == DXOp::SampleCmpGrad) || + (dxOpCode == DXOp::SampleCmpBias)); showDxFuncName = false; rdcstr handleStr = ArgToString(inst.args[1], false); const ResourceReference *resRef = GetResourceReference(handleStr); @@ -2797,7 +2793,7 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { lineStr += resRef->resourceBase.name; lineStr += "."; - rdcstr dxFuncSig = funcNameSigs[dxopCode]; + rdcstr dxFuncSig = funcNameSigs[(uint32_t)dxOpCode]; int paramStart = dxFuncSig.find('(') + 1; if(paramStart > 0) lineStr += dxFuncSig.substr(0, paramStart); @@ -2882,9 +2878,9 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) { // AtomicBinOp(handle, atomicOp, offset0, offset1, offset2, newValue) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::atomicBinOp); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::AtomicBinOp); rdcstr handleStr = ArgToString(inst.args[1], false); AtomicBinOpCode atomicBinOpCode; const ResourceReference *resRef = GetResourceReference(handleStr); @@ -2926,23 +2922,23 @@ void Program::MakeRDDisassemblyString(const DXBC::Reflection *reflection) // Dot3(ax,ay,az,bx,by,bz) // Dot2(ax,ay,bx,by) showDxFuncName = false; - uint32_t dxopCode; - RDCASSERT(getival(inst.args[0], dxopCode)); + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); uint32_t countComponents = 0; if(funcCallName.beginsWith("dx.op.dot4")) { countComponents = 4; - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::dot4); + RDCASSERTEQUAL(dxOpCode, DXOp::Dot4); } else if(funcCallName.beginsWith("dx.op.dot3")) { countComponents = 3; - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::dot3); + RDCASSERTEQUAL(dxOpCode, DXOp::Dot3); } else if(funcCallName.beginsWith("dx.op.dot2")) { countComponents = 2; - RDCASSERTEQUAL(dxopCode, (uint32_t)DXOp::dot2); + RDCASSERTEQUAL(dxOpCode, DXOp::Dot2); } lineStr += "dot("; lineStr += "{"; @@ -4043,6 +4039,10 @@ void Program::ParseReferences(const DXBC::Reflection *reflection) rdcstr funcCallName = inst.getFuncCall()->name; if(funcCallName.beginsWith("dx.op.createHandle")) { + DXOp dxOpCode; + RDCASSERT(getival(inst.args[0], dxOpCode)); + RDCASSERTEQUAL(dxOpCode, DXOp::CreateHandle); + ResourceClass resClass; uint32_t resIndex; if(getival(inst.args[1], resClass) && diff --git a/renderdoc/driver/shaders/dxil/dxil_reflect.cpp b/renderdoc/driver/shaders/dxil/dxil_reflect.cpp index abfbf33d7..be42a962a 100644 --- a/renderdoc/driver/shaders/dxil/dxil_reflect.cpp +++ b/renderdoc/driver/shaders/dxil/dxil_reflect.cpp @@ -1769,3 +1769,270 @@ void Program::ProcessFunctions(std::function callback) c } }; // namespace DXIL + +template <> +rdcstr DoStringise(const DXIL::DXOp &el) +{ + BEGIN_ENUM_STRINGISE(DXIL::DXOp); + { + STRINGISE_ENUM_CLASS(TempRegLoad); + STRINGISE_ENUM_CLASS(TempRegStore); + STRINGISE_ENUM_CLASS(MinPrecXRegLoad); + STRINGISE_ENUM_CLASS(MinPrecXRegStore); + STRINGISE_ENUM_CLASS(LoadInput); + STRINGISE_ENUM_CLASS(StoreOutput); + STRINGISE_ENUM_CLASS(FAbs); + STRINGISE_ENUM_CLASS(Saturate); + STRINGISE_ENUM_CLASS(IsNaN); + STRINGISE_ENUM_CLASS(IsInf); + STRINGISE_ENUM_CLASS(IsFinite); + STRINGISE_ENUM_CLASS(IsNormal); + STRINGISE_ENUM_CLASS(Cos); + STRINGISE_ENUM_CLASS(Sin); + STRINGISE_ENUM_CLASS(Tan); + STRINGISE_ENUM_CLASS(Acos); + STRINGISE_ENUM_CLASS(Asin); + STRINGISE_ENUM_CLASS(Atan); + STRINGISE_ENUM_CLASS(Hcos); + STRINGISE_ENUM_CLASS(Hsin); + STRINGISE_ENUM_CLASS(Htan); + STRINGISE_ENUM_CLASS(Exp); + STRINGISE_ENUM_CLASS(Frc); + STRINGISE_ENUM_CLASS(Log); + STRINGISE_ENUM_CLASS(Sqrt); + STRINGISE_ENUM_CLASS(Rsqrt); + STRINGISE_ENUM_CLASS(Round_ne); + STRINGISE_ENUM_CLASS(Round_ni); + STRINGISE_ENUM_CLASS(Round_pi); + STRINGISE_ENUM_CLASS(Round_z); + STRINGISE_ENUM_CLASS(Bfrev); + STRINGISE_ENUM_CLASS(Countbits); + STRINGISE_ENUM_CLASS(FirstbitLo); + STRINGISE_ENUM_CLASS(FirstbitHi); + STRINGISE_ENUM_CLASS(FirstbitSHi); + STRINGISE_ENUM_CLASS(FMax); + STRINGISE_ENUM_CLASS(FMin); + STRINGISE_ENUM_CLASS(IMax); + STRINGISE_ENUM_CLASS(IMin); + STRINGISE_ENUM_CLASS(UMax); + STRINGISE_ENUM_CLASS(UMin); + STRINGISE_ENUM_CLASS(IMul); + STRINGISE_ENUM_CLASS(UMul); + STRINGISE_ENUM_CLASS(UDiv); + STRINGISE_ENUM_CLASS(UAddc); + STRINGISE_ENUM_CLASS(USubb); + STRINGISE_ENUM_CLASS(FMad); + STRINGISE_ENUM_CLASS(Fma); + STRINGISE_ENUM_CLASS(IMad); + STRINGISE_ENUM_CLASS(UMad); + STRINGISE_ENUM_CLASS(Msad); + STRINGISE_ENUM_CLASS(Ibfe); + STRINGISE_ENUM_CLASS(Ubfe); + STRINGISE_ENUM_CLASS(Bfi); + STRINGISE_ENUM_CLASS(Dot2); + STRINGISE_ENUM_CLASS(Dot3); + STRINGISE_ENUM_CLASS(Dot4); + STRINGISE_ENUM_CLASS(CreateHandle); + STRINGISE_ENUM_CLASS(CBufferLoad); + STRINGISE_ENUM_CLASS(CBufferLoadLegacy); + STRINGISE_ENUM_CLASS(Sample); + STRINGISE_ENUM_CLASS(SampleBias); + STRINGISE_ENUM_CLASS(SampleLevel); + STRINGISE_ENUM_CLASS(SampleGrad); + STRINGISE_ENUM_CLASS(SampleCmp); + STRINGISE_ENUM_CLASS(SampleCmpLevelZero); + STRINGISE_ENUM_CLASS(TextureLoad); + STRINGISE_ENUM_CLASS(TextureStore); + STRINGISE_ENUM_CLASS(BufferLoad); + STRINGISE_ENUM_CLASS(BufferStore); + STRINGISE_ENUM_CLASS(BufferUpdateCounter); + STRINGISE_ENUM_CLASS(CheckAccessFullyMapped); + STRINGISE_ENUM_CLASS(GetDimensions); + STRINGISE_ENUM_CLASS(TextureGather); + STRINGISE_ENUM_CLASS(TextureGatherCmp); + STRINGISE_ENUM_CLASS(Texture2DMSGetSamplePosition); + STRINGISE_ENUM_CLASS(RenderTargetGetSamplePosition); + STRINGISE_ENUM_CLASS(RenderTargetGetSampleCount); + STRINGISE_ENUM_CLASS(AtomicBinOp); + STRINGISE_ENUM_CLASS(AtomicCompareExchange); + STRINGISE_ENUM_CLASS(Barrier); + STRINGISE_ENUM_CLASS(CalculateLOD); + STRINGISE_ENUM_CLASS(Discard); + STRINGISE_ENUM_CLASS(DerivCoarseX); + STRINGISE_ENUM_CLASS(DerivCoarseY); + STRINGISE_ENUM_CLASS(DerivFineX); + STRINGISE_ENUM_CLASS(DerivFineY); + STRINGISE_ENUM_CLASS(EvalSnapped); + STRINGISE_ENUM_CLASS(EvalSampleIndex); + STRINGISE_ENUM_CLASS(EvalCentroid); + STRINGISE_ENUM_CLASS(SampleIndex); + STRINGISE_ENUM_CLASS(Coverage); + STRINGISE_ENUM_CLASS(InnerCoverage); + STRINGISE_ENUM_CLASS(ThreadId); + STRINGISE_ENUM_CLASS(GroupId); + STRINGISE_ENUM_CLASS(ThreadIdInGroup); + STRINGISE_ENUM_CLASS(FlattenedThreadIdInGroup); + STRINGISE_ENUM_CLASS(EmitStream); + STRINGISE_ENUM_CLASS(CutStream); + STRINGISE_ENUM_CLASS(EmitThenCutStream); + STRINGISE_ENUM_CLASS(GSInstanceID); + STRINGISE_ENUM_CLASS(MakeDouble); + STRINGISE_ENUM_CLASS(SplitDouble); + STRINGISE_ENUM_CLASS(LoadOutputControlPoint); + STRINGISE_ENUM_CLASS(LoadPatchConstant); + STRINGISE_ENUM_CLASS(DomainLocation); + STRINGISE_ENUM_CLASS(StorePatchConstant); + STRINGISE_ENUM_CLASS(OutputControlPointID); + STRINGISE_ENUM_CLASS(PrimitiveID); + STRINGISE_ENUM_CLASS(CycleCounterLegacy); + STRINGISE_ENUM_CLASS(WaveIsFirstLane); + STRINGISE_ENUM_CLASS(WaveGetLaneIndex); + STRINGISE_ENUM_CLASS(WaveGetLaneCount); + STRINGISE_ENUM_CLASS(WaveAnyTrue); + STRINGISE_ENUM_CLASS(WaveAllTrue); + STRINGISE_ENUM_CLASS(WaveActiveAllEqual); + STRINGISE_ENUM_CLASS(WaveActiveBallot); + STRINGISE_ENUM_CLASS(WaveReadLaneAt); + STRINGISE_ENUM_CLASS(WaveReadLaneFirst); + STRINGISE_ENUM_CLASS(WaveActiveOp); + STRINGISE_ENUM_CLASS(WaveActiveBit); + STRINGISE_ENUM_CLASS(WavePrefixOp); + STRINGISE_ENUM_CLASS(QuadReadLaneAt); + STRINGISE_ENUM_CLASS(QuadOp); + STRINGISE_ENUM_CLASS(BitcastI16toF16); + STRINGISE_ENUM_CLASS(BitcastF16toI16); + STRINGISE_ENUM_CLASS(BitcastI32toF32); + STRINGISE_ENUM_CLASS(BitcastF32toI32); + STRINGISE_ENUM_CLASS(BitcastI64toF64); + STRINGISE_ENUM_CLASS(BitcastF64toI64); + STRINGISE_ENUM_CLASS(LegacyF32ToF16); + STRINGISE_ENUM_CLASS(LegacyF16ToF32); + STRINGISE_ENUM_CLASS(LegacyDoubleToFloat); + STRINGISE_ENUM_CLASS(LegacyDoubleToSInt32); + STRINGISE_ENUM_CLASS(LegacyDoubleToUInt32); + STRINGISE_ENUM_CLASS(WaveAllBitCount); + STRINGISE_ENUM_CLASS(WavePrefixBitCount); + STRINGISE_ENUM_CLASS(AttributeAtVertex); + STRINGISE_ENUM_CLASS(ViewID); + STRINGISE_ENUM_CLASS(RawBufferLoad); + STRINGISE_ENUM_CLASS(RawBufferStore); + STRINGISE_ENUM_CLASS(InstanceID); + STRINGISE_ENUM_CLASS(InstanceIndex); + STRINGISE_ENUM_CLASS(HitKind); + STRINGISE_ENUM_CLASS(RayFlags); + STRINGISE_ENUM_CLASS(DispatchRaysIndex); + STRINGISE_ENUM_CLASS(DispatchRaysDimensions); + STRINGISE_ENUM_CLASS(WorldRayOrigin); + STRINGISE_ENUM_CLASS(WorldRayDirection); + STRINGISE_ENUM_CLASS(ObjectRayOrigin); + STRINGISE_ENUM_CLASS(ObjectRayDirection); + STRINGISE_ENUM_CLASS(ObjectToWorld); + STRINGISE_ENUM_CLASS(WorldToObject); + STRINGISE_ENUM_CLASS(RayTMin); + STRINGISE_ENUM_CLASS(RayTCurrent); + STRINGISE_ENUM_CLASS(IgnoreHit); + STRINGISE_ENUM_CLASS(AcceptHitAndEndSearch); + STRINGISE_ENUM_CLASS(TraceRay); + STRINGISE_ENUM_CLASS(ReportHit); + STRINGISE_ENUM_CLASS(CallShader); + STRINGISE_ENUM_CLASS(CreateHandleForLib); + STRINGISE_ENUM_CLASS(PrimitiveIndex); + STRINGISE_ENUM_CLASS(Dot2AddHalf); + STRINGISE_ENUM_CLASS(Dot4AddI8Packed); + STRINGISE_ENUM_CLASS(Dot4AddU8Packed); + STRINGISE_ENUM_CLASS(WaveMatch); + STRINGISE_ENUM_CLASS(WaveMultiPrefixOp); + STRINGISE_ENUM_CLASS(WaveMultiPrefixBitCount); + STRINGISE_ENUM_CLASS(SetMeshOutputCounts); + STRINGISE_ENUM_CLASS(EmitIndices); + STRINGISE_ENUM_CLASS(GetMeshPayload); + STRINGISE_ENUM_CLASS(StoreVertexOutput); + STRINGISE_ENUM_CLASS(StorePrimitiveOutput); + STRINGISE_ENUM_CLASS(DispatchMesh); + STRINGISE_ENUM_CLASS(WriteSamplerFeedback); + STRINGISE_ENUM_CLASS(WriteSamplerFeedbackBias); + STRINGISE_ENUM_CLASS(WriteSamplerFeedbackLevel); + STRINGISE_ENUM_CLASS(WriteSamplerFeedbackGrad); + STRINGISE_ENUM_CLASS(AllocateRayQuery); + STRINGISE_ENUM_CLASS(RayQuery_TraceRayInline); + STRINGISE_ENUM_CLASS(RayQuery_Proceed); + STRINGISE_ENUM_CLASS(RayQuery_Abort); + STRINGISE_ENUM_CLASS(RayQuery_CommitNonOpaqueTriangleHit); + STRINGISE_ENUM_CLASS(RayQuery_CommitProceduralPrimitiveHit); + STRINGISE_ENUM_CLASS(RayQuery_CommittedStatus); + STRINGISE_ENUM_CLASS(RayQuery_CandidateType); + STRINGISE_ENUM_CLASS(RayQuery_CandidateObjectToWorld3x4); + STRINGISE_ENUM_CLASS(RayQuery_CandidateWorldToObject3x4); + STRINGISE_ENUM_CLASS(RayQuery_CommittedObjectToWorld3x4); + STRINGISE_ENUM_CLASS(RayQuery_CommittedWorldToObject3x4); + STRINGISE_ENUM_CLASS(RayQuery_CandidateProceduralPrimitiveNonOpaque); + STRINGISE_ENUM_CLASS(RayQuery_CandidateTriangleFrontFace); + STRINGISE_ENUM_CLASS(RayQuery_CommittedTriangleFrontFace); + STRINGISE_ENUM_CLASS(RayQuery_CandidateTriangleBarycentrics); + STRINGISE_ENUM_CLASS(RayQuery_CommittedTriangleBarycentrics); + STRINGISE_ENUM_CLASS(RayQuery_RayFlags); + STRINGISE_ENUM_CLASS(RayQuery_WorldRayOrigin); + STRINGISE_ENUM_CLASS(RayQuery_WorldRayDirection); + STRINGISE_ENUM_CLASS(RayQuery_RayTMin); + STRINGISE_ENUM_CLASS(RayQuery_CandidateTriangleRayT); + STRINGISE_ENUM_CLASS(RayQuery_CommittedRayT); + STRINGISE_ENUM_CLASS(RayQuery_CandidateInstanceIndex); + STRINGISE_ENUM_CLASS(RayQuery_CandidateInstanceID); + STRINGISE_ENUM_CLASS(RayQuery_CandidateGeometryIndex); + STRINGISE_ENUM_CLASS(RayQuery_CandidatePrimitiveIndex); + STRINGISE_ENUM_CLASS(RayQuery_CandidateObjectRayOrigin); + STRINGISE_ENUM_CLASS(RayQuery_CandidateObjectRayDirection); + STRINGISE_ENUM_CLASS(RayQuery_CommittedInstanceIndex); + STRINGISE_ENUM_CLASS(RayQuery_CommittedInstanceID); + STRINGISE_ENUM_CLASS(RayQuery_CommittedGeometryIndex); + STRINGISE_ENUM_CLASS(RayQuery_CommittedPrimitiveIndex); + STRINGISE_ENUM_CLASS(RayQuery_CommittedObjectRayOrigin); + STRINGISE_ENUM_CLASS(RayQuery_CommittedObjectRayDirection); + STRINGISE_ENUM_CLASS(GeometryIndex); + STRINGISE_ENUM_CLASS(RayQuery_CandidateInstanceContributionToHitGroupIndex); + STRINGISE_ENUM_CLASS(RayQuery_CommittedInstanceContributionToHitGroupIndex); + STRINGISE_ENUM_CLASS(AnnotateHandle); + STRINGISE_ENUM_CLASS(CreateHandleFromBinding); + STRINGISE_ENUM_CLASS(CreateHandleFromHeap); + STRINGISE_ENUM_CLASS(Unpack4x8); + STRINGISE_ENUM_CLASS(Pack4x8); + STRINGISE_ENUM_CLASS(IsHelperLane); + STRINGISE_ENUM_CLASS(QuadVote); + STRINGISE_ENUM_CLASS(TextureGatherRaw); + STRINGISE_ENUM_CLASS(SampleCmpLevel); + STRINGISE_ENUM_CLASS(TextureStoreSample); + STRINGISE_ENUM_CLASS(WaveMatrix_Annotate); + STRINGISE_ENUM_CLASS(WaveMatrix_Depth); + STRINGISE_ENUM_CLASS(WaveMatrix_Fill); + STRINGISE_ENUM_CLASS(WaveMatrix_LoadRawBuf); + STRINGISE_ENUM_CLASS(WaveMatrix_LoadGroupShared); + STRINGISE_ENUM_CLASS(WaveMatrix_StoreRawBuf); + STRINGISE_ENUM_CLASS(WaveMatrix_StoreGroupShared); + STRINGISE_ENUM_CLASS(WaveMatrix_Multiply); + STRINGISE_ENUM_CLASS(WaveMatrix_MultiplyAccumulate); + STRINGISE_ENUM_CLASS(WaveMatrix_ScalarOp); + STRINGISE_ENUM_CLASS(WaveMatrix_SumAccumulate); + STRINGISE_ENUM_CLASS(WaveMatrix_Add); + STRINGISE_ENUM_CLASS(AllocateNodeOutputRecords); + STRINGISE_ENUM_CLASS(GetNodeRecordPtr); + STRINGISE_ENUM_CLASS(IncrementOutputCount); + STRINGISE_ENUM_CLASS(OutputComplete); + STRINGISE_ENUM_CLASS(GetInputRecordCount); + STRINGISE_ENUM_CLASS(FinishedCrossGroupSharing); + STRINGISE_ENUM_CLASS(BarrierByMemoryType); + STRINGISE_ENUM_CLASS(BarrierByMemoryHandle); + STRINGISE_ENUM_CLASS(BarrierByNodeRecordHandle); + STRINGISE_ENUM_CLASS(CreateNodeOutputHandle); + STRINGISE_ENUM_CLASS(IndexNodeHandle); + STRINGISE_ENUM_CLASS(AnnotateNodeHandle); + STRINGISE_ENUM_CLASS(CreateNodeInputRecordHandle); + STRINGISE_ENUM_CLASS(AnnotateNodeRecordHandle); + STRINGISE_ENUM_CLASS(NodeOutputIsValid); + STRINGISE_ENUM_CLASS(GetRemainingRecursionLevels); + STRINGISE_ENUM_CLASS(SampleCmpGrad); + STRINGISE_ENUM_CLASS(SampleCmpBias); + STRINGISE_ENUM_CLASS(StartVertexLocation); + STRINGISE_ENUM_CLASS(StartInstanceLocation); + } + END_ENUM_STRINGISE(); +}