You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1751 lines
56 KiB
C
1751 lines
56 KiB
C
// Modifications copyright Amazon.com, Inc. or its affiliates
|
|
// Modifications copyright Crytek GmbH
|
|
|
|
#include "internal_includes/tokens.h"
|
|
#include "internal_includes/structs.h"
|
|
#include "internal_includes/decode.h"
|
|
#include "stdlib.h"
|
|
#include "stdio.h"
|
|
#include "internal_includes/reflect.h"
|
|
#include "internal_includes/debug.h"
|
|
#include "internal_includes/hlslcc_malloc.h"
|
|
#include "internal_includes/toGLSLOperand.h"
|
|
|
|
#define FOURCC(a, b, c, d) ((uint32_t)(uint8_t)(a) | ((uint32_t)(uint8_t)(b) << 8) | ((uint32_t)(uint8_t)(c) << 16) | ((uint32_t)(uint8_t)(d) << 24))
|
|
enum
|
|
{
|
|
FOURCC_DXBC = FOURCC('D', 'X', 'B', 'C')
|
|
}; //DirectX byte code
|
|
enum
|
|
{
|
|
FOURCC_SHDR = FOURCC('S', 'H', 'D', 'R')
|
|
}; //Shader model 4 code
|
|
enum
|
|
{
|
|
FOURCC_SHEX = FOURCC('S', 'H', 'E', 'X')
|
|
}; //Shader model 5 code
|
|
enum
|
|
{
|
|
FOURCC_RDEF = FOURCC('R', 'D', 'E', 'F')
|
|
}; //Resource definition (e.g. constant buffers)
|
|
enum
|
|
{
|
|
FOURCC_ISGN = FOURCC('I', 'S', 'G', 'N')
|
|
}; //Input signature
|
|
enum
|
|
{
|
|
FOURCC_IFCE = FOURCC('I', 'F', 'C', 'E')
|
|
}; //Interface (for dynamic linking)
|
|
enum
|
|
{
|
|
FOURCC_OSGN = FOURCC('O', 'S', 'G', 'N')
|
|
}; //Output signature
|
|
enum
|
|
{
|
|
FOURCC_PSGN = FOURCC('P', 'C', 'S', 'G')
|
|
}; //Patch-constant signature
|
|
enum
|
|
{
|
|
FOURCC_FX10 = FOURCC('F', 'X', '1', '0')
|
|
}; //Effects 10 Binary data
|
|
|
|
enum
|
|
{
|
|
FOURCC_ISG1 = FOURCC('I', 'S', 'G', '1')
|
|
}; //Input signature with Stream and MinPrecision
|
|
enum
|
|
{
|
|
FOURCC_OSG1 = FOURCC('O', 'S', 'G', '1')
|
|
}; //Output signature with Stream and MinPrecision
|
|
enum
|
|
{
|
|
FOURCC_OSG5 = FOURCC('O', 'S', 'G', '5')
|
|
}; //Output signature with Stream
|
|
|
|
typedef struct DXBCContainerHeaderTAG
|
|
{
|
|
unsigned fourcc;
|
|
uint32_t unk[4];
|
|
uint32_t one;
|
|
uint32_t totalSize;
|
|
uint32_t chunkCount;
|
|
} DXBCContainerHeader;
|
|
|
|
typedef struct DXBCChunkHeaderTAG
|
|
{
|
|
unsigned fourcc;
|
|
unsigned size;
|
|
} DXBCChunkHeader;
|
|
|
|
#ifdef _DEBUG
|
|
static uint64_t operandID = 0;
|
|
static uint64_t instructionID = 0;
|
|
#endif
|
|
|
|
#if defined(_WIN32)
|
|
#define osSprintf(dest, size, src) sprintf_s(dest, size, src)
|
|
#else
|
|
#define osSprintf(dest, size, src) sprintf(dest, src)
|
|
#endif
|
|
|
|
void DecodeNameToken(const uint32_t* pui32NameToken, Operand* psOperand)
|
|
{
|
|
const size_t MAX_BUFFER_SIZE = sizeof(psOperand->pszSpecialName);
|
|
psOperand->eSpecialName = DecodeOperandSpecialName(*pui32NameToken);
|
|
switch (psOperand->eSpecialName)
|
|
{
|
|
case NAME_UNDEFINED:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "undefined");
|
|
break;
|
|
}
|
|
case NAME_POSITION:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "position");
|
|
break;
|
|
}
|
|
case NAME_CLIP_DISTANCE:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "clipDistance");
|
|
break;
|
|
}
|
|
case NAME_CULL_DISTANCE:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "cullDistance");
|
|
break;
|
|
}
|
|
case NAME_RENDER_TARGET_ARRAY_INDEX:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "renderTargetArrayIndex");
|
|
break;
|
|
}
|
|
case NAME_VIEWPORT_ARRAY_INDEX:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "viewportArrayIndex");
|
|
break;
|
|
}
|
|
case NAME_VERTEX_ID:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "vertexID");
|
|
break;
|
|
}
|
|
case NAME_PRIMITIVE_ID:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "primitiveID");
|
|
break;
|
|
}
|
|
case NAME_INSTANCE_ID:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "instanceID");
|
|
break;
|
|
}
|
|
case NAME_IS_FRONT_FACE:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "isFrontFace");
|
|
break;
|
|
}
|
|
case NAME_SAMPLE_INDEX:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "sampleIndex");
|
|
break;
|
|
}
|
|
//For the quadrilateral domain, there are 6 factors (4 sides, 2 inner).
|
|
case NAME_FINAL_QUAD_U_EQ_0_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_QUAD_V_EQ_0_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_QUAD_U_EQ_1_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_QUAD_V_EQ_1_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_QUAD_U_INSIDE_TESSFACTOR:
|
|
case NAME_FINAL_QUAD_V_INSIDE_TESSFACTOR:
|
|
|
|
//For the triangular domain, there are 4 factors (3 sides, 1 inner)
|
|
case NAME_FINAL_TRI_U_EQ_0_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_TRI_V_EQ_0_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_TRI_W_EQ_0_EDGE_TESSFACTOR:
|
|
case NAME_FINAL_TRI_INSIDE_TESSFACTOR:
|
|
|
|
//For the isoline domain, there are 2 factors (detail and density).
|
|
case NAME_FINAL_LINE_DETAIL_TESSFACTOR:
|
|
case NAME_FINAL_LINE_DENSITY_TESSFACTOR:
|
|
{
|
|
osSprintf(psOperand->pszSpecialName, MAX_BUFFER_SIZE, "tessFactor");
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Find the declaration of the texture described by psTextureOperand and
|
|
// mark it as a shadow type. (e.g. accessed via sampler2DShadow rather than sampler2D)
|
|
void MarkTextureAsShadow(ShaderInfo* psShaderInfo, Declaration* psDeclList, const uint32_t ui32DeclCount, const Operand* psTextureOperand)
|
|
{
|
|
(void)psShaderInfo;
|
|
|
|
Declaration* psDecl = psDeclList;
|
|
uint32_t i;
|
|
|
|
ASSERT(psTextureOperand->eType == OPERAND_TYPE_RESOURCE);
|
|
|
|
for (i = 0; i < ui32DeclCount; ++i)
|
|
{
|
|
if (psDecl->eOpcode == OPCODE_DCL_RESOURCE)
|
|
{
|
|
if (psDecl->asOperands[0].eType == OPERAND_TYPE_RESOURCE &&
|
|
psDecl->asOperands[0].ui32RegisterNumber == psTextureOperand->ui32RegisterNumber)
|
|
{
|
|
psDecl->ui32IsShadowTex = 1;
|
|
break;
|
|
}
|
|
}
|
|
psDecl++;
|
|
}
|
|
}
|
|
|
|
// Search through the list. Return the index if the value is found, return 0xffffffff if not found
|
|
static uint32_t Find(uint32_t* psList, uint32_t ui32Count, uint32_t ui32Value)
|
|
{
|
|
uint32_t i;
|
|
for (i = 0; i < ui32Count; i++)
|
|
{
|
|
if (psList[i] == ui32Value)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return 0xffffffff;
|
|
}
|
|
|
|
void MarkTextureSamplerPair(ShaderInfo* psShaderInfo, Declaration* psDeclList, const uint32_t ui32DeclCount, const Operand* psTextureOperand, const Operand* psSamplerOperand, TextureSamplerInfo* psTextureSamplerInfo)
|
|
{
|
|
Declaration* psDecl = psDeclList;
|
|
uint32_t i;
|
|
bstring combinedname;
|
|
const char* cstr;
|
|
|
|
ASSERT(psTextureOperand->eType == OPERAND_TYPE_RESOURCE);
|
|
ASSERT(psSamplerOperand->eType == OPERAND_TYPE_SAMPLER);
|
|
|
|
for (i = 0; i < ui32DeclCount; ++i)
|
|
{
|
|
if (psDecl->eOpcode == OPCODE_DCL_RESOURCE)
|
|
{
|
|
if (psDecl->asOperands[0].eType == OPERAND_TYPE_RESOURCE &&
|
|
psDecl->asOperands[0].ui32RegisterNumber == psTextureOperand->ui32RegisterNumber)
|
|
{
|
|
// psDecl is the texture resource referenced by psTextureOperand
|
|
ASSERT(psDecl->ui32SamplerUsedCount < MAX_TEXTURE_SAMPLERS_PAIRS);
|
|
|
|
// add psSamplerOperand->ui32RegisterNumber to list of samplers that use this texture
|
|
if (Find(psDecl->ui32SamplerUsed, psDecl->ui32SamplerUsedCount, psSamplerOperand->ui32RegisterNumber) == 0xffffffff)
|
|
{
|
|
psDecl->ui32SamplerUsed[psDecl->ui32SamplerUsedCount++] = psSamplerOperand->ui32RegisterNumber;
|
|
|
|
// Record the texturename_X_samplername string in the TextureSamplerPair array that we return to the client
|
|
ASSERT(psTextureSamplerInfo->ui32NumTextureSamplerPairs < MAX_RESOURCE_BINDINGS);
|
|
combinedname = TextureSamplerName(psShaderInfo, psTextureOperand->ui32RegisterNumber, psSamplerOperand->ui32RegisterNumber, psDecl->ui32IsShadowTex);
|
|
cstr = bstr2cstr(combinedname, '\0');
|
|
bdestroy(combinedname);
|
|
strcpy(psTextureSamplerInfo->aTextureSamplerPair[psTextureSamplerInfo->ui32NumTextureSamplerPairs++].Name, cstr);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
psDecl++;
|
|
}
|
|
}
|
|
|
|
uint32_t DecodeOperand (const uint32_t* pui32Tokens, Operand* psOperand)
|
|
{
|
|
int i;
|
|
uint32_t ui32NumTokens = 1;
|
|
OPERAND_NUM_COMPONENTS eNumComponents;
|
|
|
|
#ifdef _DEBUG
|
|
psOperand->id = operandID++;
|
|
#endif
|
|
|
|
//Some defaults
|
|
psOperand->iWriteMaskEnabled = 1;
|
|
psOperand->iGSInput = 0;
|
|
psOperand->aeDataType[0] = SVT_FLOAT;
|
|
psOperand->aeDataType[1] = SVT_FLOAT;
|
|
psOperand->aeDataType[2] = SVT_FLOAT;
|
|
psOperand->aeDataType[3] = SVT_FLOAT;
|
|
|
|
psOperand->iExtended = DecodeIsOperandExtended(*pui32Tokens);
|
|
|
|
|
|
psOperand->eModifier = OPERAND_MODIFIER_NONE;
|
|
psOperand->psSubOperand[0] = 0;
|
|
psOperand->psSubOperand[1] = 0;
|
|
psOperand->psSubOperand[2] = 0;
|
|
|
|
psOperand->eMinPrecision = OPERAND_MIN_PRECISION_DEFAULT;
|
|
|
|
/* Check if this instruction is extended. If it is,
|
|
* we need to print the information first */
|
|
if (psOperand->iExtended)
|
|
{
|
|
/* OperandToken1 is the second token */
|
|
ui32NumTokens++;
|
|
|
|
if (DecodeExtendedOperandType(pui32Tokens[1]) == EXTENDED_OPERAND_MODIFIER)
|
|
{
|
|
psOperand->eModifier = DecodeExtendedOperandModifier(pui32Tokens[1]);
|
|
psOperand->eMinPrecision = DecodeOperandMinPrecision(pui32Tokens[1]);
|
|
}
|
|
}
|
|
|
|
psOperand->iIndexDims = DecodeOperandIndexDimension(*pui32Tokens);
|
|
psOperand->eType = DecodeOperandType(*pui32Tokens);
|
|
|
|
psOperand->ui32RegisterNumber = 0;
|
|
|
|
eNumComponents = DecodeOperandNumComponents(*pui32Tokens);
|
|
|
|
if (psOperand->eType == OPERAND_TYPE_INPUT_GS_INSTANCE_ID)
|
|
{
|
|
eNumComponents = OPERAND_1_COMPONENT;
|
|
psOperand->aeDataType[0] = SVT_UINT;
|
|
}
|
|
|
|
switch (eNumComponents)
|
|
{
|
|
case OPERAND_1_COMPONENT:
|
|
{
|
|
psOperand->iNumComponents = 1;
|
|
break;
|
|
}
|
|
case OPERAND_4_COMPONENT:
|
|
{
|
|
psOperand->iNumComponents = 4;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
psOperand->iNumComponents = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (psOperand->iWriteMaskEnabled &&
|
|
psOperand->iNumComponents == 4)
|
|
{
|
|
psOperand->eSelMode = DecodeOperand4CompSelMode(*pui32Tokens);
|
|
|
|
if (psOperand->eSelMode == OPERAND_4_COMPONENT_MASK_MODE)
|
|
{
|
|
psOperand->ui32CompMask = DecodeOperand4CompMask(*pui32Tokens);
|
|
}
|
|
else
|
|
if (psOperand->eSelMode == OPERAND_4_COMPONENT_SWIZZLE_MODE)
|
|
{
|
|
psOperand->ui32Swizzle = DecodeOperand4CompSwizzle(*pui32Tokens);
|
|
|
|
if (psOperand->ui32Swizzle != NO_SWIZZLE)
|
|
{
|
|
psOperand->aui32Swizzle[0] = DecodeOperand4CompSwizzleSource(*pui32Tokens, 0);
|
|
psOperand->aui32Swizzle[1] = DecodeOperand4CompSwizzleSource(*pui32Tokens, 1);
|
|
psOperand->aui32Swizzle[2] = DecodeOperand4CompSwizzleSource(*pui32Tokens, 2);
|
|
psOperand->aui32Swizzle[3] = DecodeOperand4CompSwizzleSource(*pui32Tokens, 3);
|
|
}
|
|
else
|
|
{
|
|
psOperand->aui32Swizzle[0] = OPERAND_4_COMPONENT_X;
|
|
psOperand->aui32Swizzle[1] = OPERAND_4_COMPONENT_Y;
|
|
psOperand->aui32Swizzle[2] = OPERAND_4_COMPONENT_Z;
|
|
psOperand->aui32Swizzle[3] = OPERAND_4_COMPONENT_W;
|
|
}
|
|
}
|
|
else
|
|
if (psOperand->eSelMode == OPERAND_4_COMPONENT_SELECT_1_MODE)
|
|
{
|
|
psOperand->aui32Swizzle[0] = DecodeOperand4CompSel1(*pui32Tokens);
|
|
}
|
|
}
|
|
|
|
//Set externally to this function based on the instruction opcode.
|
|
psOperand->iIntegerImmediate = 0;
|
|
|
|
if (psOperand->eType == OPERAND_TYPE_IMMEDIATE32)
|
|
{
|
|
for (i = 0; i < psOperand->iNumComponents; ++i)
|
|
{
|
|
psOperand->afImmediates[i] = *((float*)(&pui32Tokens[ui32NumTokens]));
|
|
ui32NumTokens++;
|
|
}
|
|
}
|
|
else
|
|
if (psOperand->eType == OPERAND_TYPE_IMMEDIATE64)
|
|
{
|
|
for (i = 0; i < psOperand->iNumComponents; ++i)
|
|
{
|
|
psOperand->adImmediates[i] = *((double*)(&pui32Tokens[ui32NumTokens]));
|
|
ui32NumTokens += 2;
|
|
}
|
|
}
|
|
|
|
if (psOperand->eType == OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL ||
|
|
psOperand->eType == OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL ||
|
|
psOperand->eType == OPERAND_TYPE_OUTPUT_DEPTH)
|
|
{
|
|
psOperand->ui32RegisterNumber = -1;
|
|
psOperand->ui32CompMask = -1;
|
|
}
|
|
|
|
for (i = 0; i < psOperand->iIndexDims; ++i)
|
|
{
|
|
OPERAND_INDEX_REPRESENTATION eRep = DecodeOperandIndexRepresentation(i, *pui32Tokens);
|
|
|
|
psOperand->eIndexRep[i] = eRep;
|
|
|
|
psOperand->aui32ArraySizes[i] = 0;
|
|
psOperand->ui32RegisterNumber = 0;
|
|
|
|
switch (eRep)
|
|
{
|
|
case OPERAND_INDEX_IMMEDIATE32:
|
|
{
|
|
psOperand->ui32RegisterNumber = *(pui32Tokens + ui32NumTokens);
|
|
psOperand->aui32ArraySizes[i] = psOperand->ui32RegisterNumber;
|
|
break;
|
|
}
|
|
case OPERAND_INDEX_RELATIVE:
|
|
{
|
|
psOperand->psSubOperand[i] = hlslcc_malloc(sizeof(Operand));
|
|
DecodeOperand(pui32Tokens + ui32NumTokens, psOperand->psSubOperand[i]);
|
|
|
|
ui32NumTokens++;
|
|
break;
|
|
}
|
|
case OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE:
|
|
{
|
|
psOperand->ui32RegisterNumber = *(pui32Tokens + ui32NumTokens);
|
|
psOperand->aui32ArraySizes[i] = psOperand->ui32RegisterNumber;
|
|
|
|
ui32NumTokens++;
|
|
|
|
psOperand->psSubOperand[i] = hlslcc_malloc(sizeof(Operand));
|
|
DecodeOperand(pui32Tokens + ui32NumTokens, psOperand->psSubOperand[i]);
|
|
|
|
ui32NumTokens++;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ui32NumTokens++;
|
|
}
|
|
|
|
psOperand->pszSpecialName[0] = '\0';
|
|
|
|
return ui32NumTokens;
|
|
}
|
|
|
|
const uint32_t* DecodeDeclaration(ShaderData* psShader, const uint32_t* pui32Token, Declaration* psDecl)
|
|
{
|
|
uint32_t ui32TokenLength = DecodeInstructionLength(*pui32Token);
|
|
const uint32_t bExtended = DecodeIsOpcodeExtended(*pui32Token);
|
|
const OPCODE_TYPE eOpcode = DecodeOpcodeType(*pui32Token);
|
|
uint32_t ui32OperandOffset = 1;
|
|
|
|
if (eOpcode < NUM_OPCODES && eOpcode >= 0)
|
|
{
|
|
psShader->aiOpcodeUsed[eOpcode] = 1;
|
|
}
|
|
|
|
psDecl->eOpcode = eOpcode;
|
|
|
|
psDecl->ui32IsShadowTex = 0;
|
|
|
|
if (bExtended)
|
|
{
|
|
ui32OperandOffset = 2;
|
|
}
|
|
|
|
switch (eOpcode)
|
|
{
|
|
case OPCODE_DCL_RESOURCE: // DCL* opcodes have
|
|
{
|
|
psDecl->value.eResourceDimension = DecodeResourceDimension(*pui32Token);
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->ui32SamplerUsedCount = 0;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_CONSTANT_BUFFER: // custom operand formats.
|
|
{
|
|
psDecl->value.eCBAccessPattern = DecodeConstantBufferAccessPattern(*pui32Token);
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_SAMPLER:
|
|
{
|
|
ResourceBinding* psBinding = 0;
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
|
|
if (psDecl->asOperands[0].eType == OPERAND_TYPE_SAMPLER &&
|
|
GetResourceFromBindingPoint(RGROUP_SAMPLER, psDecl->asOperands[0].ui32RegisterNumber, &psShader->sInfo, &psBinding))
|
|
{
|
|
psDecl->bIsComparisonSampler = psBinding->ui32Flags & SHADER_INPUT_FLAG_COMPARISON_SAMPLER;
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INDEX_RANGE:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
psDecl->value.ui32IndexRange = pui32Token[ui32OperandOffset];
|
|
|
|
if (psDecl->asOperands[0].eType == OPERAND_TYPE_INPUT)
|
|
{
|
|
uint32_t i;
|
|
const uint32_t indexRange = psDecl->value.ui32IndexRange;
|
|
const uint32_t reg = psDecl->asOperands[0].ui32RegisterNumber;
|
|
|
|
psShader->aIndexedInput[reg] = indexRange;
|
|
psShader->aIndexedInputParents[reg] = reg;
|
|
|
|
//-1 means don't declare this input because it falls in
|
|
//the range of an already declared array.
|
|
for (i = reg + 1; i < reg + indexRange; ++i)
|
|
{
|
|
psShader->aIndexedInput[i] = -1;
|
|
psShader->aIndexedInputParents[i] = reg;
|
|
}
|
|
}
|
|
|
|
if (psDecl->asOperands[0].eType == OPERAND_TYPE_OUTPUT)
|
|
{
|
|
psShader->aIndexedOutput[psDecl->asOperands[0].ui32RegisterNumber] = psDecl->value.ui32IndexRange;
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY:
|
|
{
|
|
psDecl->value.eOutputPrimitiveTopology = DecodeGSOutputPrimitiveTopology(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_GS_INPUT_PRIMITIVE:
|
|
{
|
|
psDecl->value.eInputPrimitive = DecodeGSInputPrimitive(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT:
|
|
{
|
|
psDecl->value.ui32MaxOutputVertexCount = pui32Token[1];
|
|
break;
|
|
}
|
|
case OPCODE_DCL_TESS_PARTITIONING:
|
|
{
|
|
psDecl->value.eTessPartitioning = DecodeTessPartitioning(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_TESS_DOMAIN:
|
|
{
|
|
psDecl->value.eTessDomain = DecodeTessDomain(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_TESS_OUTPUT_PRIMITIVE:
|
|
{
|
|
psDecl->value.eTessOutPrim = DecodeTessOutPrim(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_THREAD_GROUP:
|
|
{
|
|
psDecl->value.aui32WorkGroupSize[0] = pui32Token[1];
|
|
psDecl->value.aui32WorkGroupSize[1] = pui32Token[2];
|
|
psDecl->value.aui32WorkGroupSize[2] = pui32Token[3];
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INPUT:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INPUT_SIV:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
if (psShader->eShaderType == PIXEL_SHADER)
|
|
{
|
|
psDecl->value.eInterpolation = DecodeInterpolationMode(*pui32Token);
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INPUT_PS:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->value.eInterpolation = DecodeInterpolationMode(*pui32Token);
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INPUT_SGV:
|
|
case OPCODE_DCL_INPUT_PS_SGV:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
DecodeNameToken(pui32Token + 3, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INPUT_PS_SIV:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->value.eInterpolation = DecodeInterpolationMode(*pui32Token);
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
DecodeNameToken(pui32Token + 3, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_OUTPUT:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_OUTPUT_SGV:
|
|
{
|
|
break;
|
|
}
|
|
case OPCODE_DCL_OUTPUT_SIV:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
DecodeNameToken(pui32Token + 3, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_TEMPS:
|
|
{
|
|
psDecl->value.ui32NumTemps = *(pui32Token + ui32OperandOffset);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INDEXABLE_TEMP:
|
|
{
|
|
psDecl->sIdxTemp.ui32RegIndex = *(pui32Token + ui32OperandOffset);
|
|
psDecl->sIdxTemp.ui32RegCount = *(pui32Token + ui32OperandOffset + 1);
|
|
psDecl->sIdxTemp.ui32RegComponentSize = *(pui32Token + ui32OperandOffset + 2);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_GLOBAL_FLAGS:
|
|
{
|
|
psDecl->value.ui32GlobalFlags = DecodeGlobalFlags(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INTERFACE:
|
|
{
|
|
uint32_t func = 0, numClassesImplementingThisInterface, arrayLen, interfaceID;
|
|
interfaceID = pui32Token[ui32OperandOffset];
|
|
ui32OperandOffset++;
|
|
psDecl->ui32TableLength = pui32Token[ui32OperandOffset];
|
|
ui32OperandOffset++;
|
|
|
|
numClassesImplementingThisInterface = DecodeInterfaceTableLength(*(pui32Token + ui32OperandOffset));
|
|
arrayLen = DecodeInterfaceArrayLength(*(pui32Token + ui32OperandOffset));
|
|
|
|
ui32OperandOffset++;
|
|
|
|
psDecl->value.interface.ui32InterfaceID = interfaceID;
|
|
psDecl->value.interface.ui32NumFuncTables = numClassesImplementingThisInterface;
|
|
psDecl->value.interface.ui32ArraySize = arrayLen;
|
|
|
|
psShader->funcPointer[interfaceID].ui32NumBodiesPerTable = psDecl->ui32TableLength;
|
|
|
|
for (; func < numClassesImplementingThisInterface; ++func)
|
|
{
|
|
uint32_t ui32FuncTable = *(pui32Token + ui32OperandOffset);
|
|
psShader->aui32FuncTableToFuncPointer[ui32FuncTable] = interfaceID;
|
|
|
|
psShader->funcPointer[interfaceID].aui32FuncTables[func] = ui32FuncTable;
|
|
ui32OperandOffset++;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case OPCODE_DCL_FUNCTION_BODY:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_FUNCTION_TABLE:
|
|
{
|
|
uint32_t ui32Func;
|
|
const uint32_t ui32FuncTableID = pui32Token[ui32OperandOffset++];
|
|
const uint32_t ui32NumFuncsInTable = pui32Token[ui32OperandOffset++];
|
|
|
|
for (ui32Func = 0; ui32Func < ui32NumFuncsInTable; ++ui32Func)
|
|
{
|
|
const uint32_t ui32FuncBodyID = pui32Token[ui32OperandOffset++];
|
|
|
|
psShader->aui32FuncBodyToFuncTable[ui32FuncBodyID] = ui32FuncTableID;
|
|
|
|
psShader->funcTable[ui32FuncTableID].aui32FuncBodies[ui32Func] = ui32FuncBodyID;
|
|
}
|
|
|
|
// OpcodeToken0 is followed by a DWORD that represents the function table
|
|
// identifier and another DWORD (TableLength) that gives the number of
|
|
// functions in the table.
|
|
//
|
|
// This is followed by TableLength DWORDs which are function body indices.
|
|
//
|
|
|
|
break;
|
|
}
|
|
case OPCODE_DCL_INPUT_CONTROL_POINT_COUNT:
|
|
{
|
|
break;
|
|
}
|
|
case OPCODE_HS_DECLS:
|
|
{
|
|
break;
|
|
}
|
|
case OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT:
|
|
{
|
|
psDecl->value.ui32MaxOutputVertexCount = DecodeOutputControlPointCount(*pui32Token);
|
|
break;
|
|
}
|
|
case OPCODE_HS_JOIN_PHASE:
|
|
case OPCODE_HS_FORK_PHASE:
|
|
case OPCODE_HS_CONTROL_POINT_PHASE:
|
|
{
|
|
break;
|
|
}
|
|
case OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT:
|
|
{
|
|
ASSERT(psShader->asPhase[HS_FORK_PHASE].ui32InstanceCount != 0); //Check for wrapping when we decrement.
|
|
psDecl->value.aui32HullPhaseInstanceInfo[0] = psShader->asPhase[HS_FORK_PHASE].ui32InstanceCount - 1;
|
|
psDecl->value.aui32HullPhaseInstanceInfo[1] = pui32Token[1];
|
|
break;
|
|
}
|
|
case OPCODE_CUSTOMDATA:
|
|
{
|
|
ui32TokenLength = pui32Token[1];
|
|
{
|
|
const uint32_t ui32NumVec4 = (ui32TokenLength - 2) / 4;
|
|
uint32_t uIdx = 0;
|
|
|
|
ICBVec4 const* pVec4Array = (void*) (pui32Token + 2);
|
|
|
|
//The buffer will contain at least one value, but not more than 4096 scalars/1024 vec4's.
|
|
ASSERT(ui32NumVec4 < MAX_IMMEDIATE_CONST_BUFFER_VEC4_SIZE);
|
|
|
|
/* must be a multiple of 4 */
|
|
ASSERT(((ui32TokenLength - 2) % 4) == 0);
|
|
|
|
for (uIdx = 0; uIdx < ui32NumVec4; uIdx++)
|
|
{
|
|
psDecl->asImmediateConstBuffer[uIdx] = pVec4Array[uIdx];
|
|
}
|
|
|
|
psDecl->ui32NumOperands = ui32NumVec4;
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_DCL_HS_MAX_TESSFACTOR:
|
|
{
|
|
psDecl->value.fMaxTessFactor = *((float*)&pui32Token[1]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED:
|
|
{
|
|
psDecl->ui32NumOperands = 2;
|
|
psDecl->value.eResourceDimension = DecodeResourceDimension(*pui32Token);
|
|
psDecl->sUAV.ui32GloballyCoherentAccess = DecodeAccessCoherencyFlags(*pui32Token);
|
|
psDecl->sUAV.bCounter = 0;
|
|
psDecl->sUAV.ui32BufferSize = 0;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
psDecl->sUAV.Type = DecodeResourceReturnType(0, pui32Token[ui32OperandOffset]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->sUAV.ui32GloballyCoherentAccess = DecodeAccessCoherencyFlags(*pui32Token);
|
|
psDecl->sUAV.bCounter = 0;
|
|
psDecl->sUAV.ui32BufferSize = 0;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
//This should be a RTYPE_UAV_RWBYTEADDRESS buffer. It is memory backed by
|
|
//a shader storage buffer whose is unknown at compile time.
|
|
psDecl->sUAV.ui32BufferSize = 0;
|
|
break;
|
|
}
|
|
case OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED:
|
|
{
|
|
ResourceBinding* psBinding = NULL;
|
|
ConstantBuffer* psBuffer = NULL;
|
|
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->sUAV.ui32GloballyCoherentAccess = DecodeAccessCoherencyFlags(*pui32Token);
|
|
psDecl->sUAV.bCounter = 0;
|
|
psDecl->sUAV.ui32BufferSize = 0;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
|
|
GetResourceFromBindingPoint(RGROUP_UAV, psDecl->asOperands[0].ui32RegisterNumber, &psShader->sInfo, &psBinding);
|
|
|
|
GetConstantBufferFromBindingPoint(RGROUP_UAV, psBinding->ui32BindPoint, &psShader->sInfo, &psBuffer);
|
|
psDecl->sUAV.ui32BufferSize = psBuffer->ui32TotalSizeInBytes;
|
|
switch (psBinding->eType)
|
|
{
|
|
case RTYPE_UAV_RWSTRUCTURED_WITH_COUNTER:
|
|
case RTYPE_UAV_APPEND_STRUCTURED:
|
|
case RTYPE_UAV_CONSUME_STRUCTURED:
|
|
psDecl->sUAV.bCounter = 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_DCL_RESOURCE_STRUCTURED:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_RESOURCE_RAW:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->sUAV.ui32GloballyCoherentAccess = 0;
|
|
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
|
|
psDecl->sTGSM.ui32Stride = pui32Token[ui32OperandOffset++];
|
|
psDecl->sTGSM.ui32Count = pui32Token[ui32OperandOffset++];
|
|
break;
|
|
}
|
|
case OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
psDecl->sUAV.ui32GloballyCoherentAccess = 0;
|
|
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
|
|
psDecl->sTGSM.ui32Stride = 4;
|
|
psDecl->sTGSM.ui32Count = pui32Token[ui32OperandOffset++];
|
|
break;
|
|
}
|
|
case OPCODE_DCL_STREAM:
|
|
{
|
|
psDecl->ui32NumOperands = 1;
|
|
DecodeOperand(pui32Token + ui32OperandOffset, &psDecl->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_DCL_GS_INSTANCE_COUNT:
|
|
{
|
|
psDecl->ui32NumOperands = 0;
|
|
psDecl->value.ui32GSInstanceCount = pui32Token[1];
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
//Reached end of declarations
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return pui32Token + ui32TokenLength;
|
|
}
|
|
|
|
const uint32_t* DeocdeInstruction(const uint32_t* pui32Token, Instruction* psInst, ShaderData* psShader)
|
|
{
|
|
uint32_t ui32TokenLength = DecodeInstructionLength(*pui32Token);
|
|
const uint32_t bExtended = DecodeIsOpcodeExtended(*pui32Token);
|
|
const OPCODE_TYPE eOpcode = DecodeOpcodeType(*pui32Token);
|
|
uint32_t ui32OperandOffset = 1;
|
|
|
|
#ifdef _DEBUG
|
|
psInst->id = instructionID++;
|
|
#endif
|
|
|
|
psInst->eOpcode = eOpcode;
|
|
|
|
psInst->bSaturate = DecodeInstructionSaturate(*pui32Token);
|
|
|
|
psInst->bAddressOffset = 0;
|
|
|
|
psInst->ui32FirstSrc = 1;
|
|
|
|
if (bExtended)
|
|
{
|
|
do
|
|
{
|
|
const uint32_t ui32ExtOpcodeToken = pui32Token[ui32OperandOffset];
|
|
const EXTENDED_OPCODE_TYPE eExtType = DecodeExtendedOpcodeType(ui32ExtOpcodeToken);
|
|
|
|
if (eExtType == EXTENDED_OPCODE_SAMPLE_CONTROLS)
|
|
{
|
|
struct
|
|
{
|
|
int i4 : 4;
|
|
} sU;
|
|
struct
|
|
{
|
|
int i4 : 4;
|
|
} sV;
|
|
struct
|
|
{
|
|
int i4 : 4;
|
|
} sW;
|
|
|
|
psInst->bAddressOffset = 1;
|
|
|
|
sU.i4 = DecodeImmediateAddressOffset(
|
|
IMMEDIATE_ADDRESS_OFFSET_U, ui32ExtOpcodeToken);
|
|
sV.i4 = DecodeImmediateAddressOffset(
|
|
IMMEDIATE_ADDRESS_OFFSET_V, ui32ExtOpcodeToken);
|
|
sW.i4 = DecodeImmediateAddressOffset(
|
|
IMMEDIATE_ADDRESS_OFFSET_W, ui32ExtOpcodeToken);
|
|
|
|
psInst->iUAddrOffset = sU.i4;
|
|
psInst->iVAddrOffset = sV.i4;
|
|
psInst->iWAddrOffset = sW.i4;
|
|
}
|
|
else if (eExtType == EXTENDED_OPCODE_RESOURCE_RETURN_TYPE)
|
|
{
|
|
psInst->xType = DecodeExtendedResourceReturnType(0, ui32ExtOpcodeToken);
|
|
psInst->yType = DecodeExtendedResourceReturnType(1, ui32ExtOpcodeToken);
|
|
psInst->zType = DecodeExtendedResourceReturnType(2, ui32ExtOpcodeToken);
|
|
psInst->wType = DecodeExtendedResourceReturnType(3, ui32ExtOpcodeToken);
|
|
}
|
|
else if (eExtType == EXTENDED_OPCODE_RESOURCE_DIM)
|
|
{
|
|
psInst->eResDim = DecodeExtendedResourceDimension(ui32ExtOpcodeToken);
|
|
}
|
|
|
|
ui32OperandOffset++;
|
|
}
|
|
while (DecodeIsOpcodeExtended(pui32Token[ui32OperandOffset - 1]));
|
|
}
|
|
|
|
if (eOpcode < NUM_OPCODES && eOpcode >= 0)
|
|
{
|
|
psShader->aiOpcodeUsed[eOpcode] = 1;
|
|
}
|
|
|
|
switch (eOpcode)
|
|
{
|
|
//no operands
|
|
case OPCODE_CUT:
|
|
case OPCODE_EMIT:
|
|
case OPCODE_EMITTHENCUT:
|
|
case OPCODE_RET:
|
|
case OPCODE_LOOP:
|
|
case OPCODE_ENDLOOP:
|
|
case OPCODE_BREAK:
|
|
case OPCODE_ELSE:
|
|
case OPCODE_ENDIF:
|
|
case OPCODE_CONTINUE:
|
|
case OPCODE_DEFAULT:
|
|
case OPCODE_ENDSWITCH:
|
|
case OPCODE_NOP:
|
|
case OPCODE_HS_CONTROL_POINT_PHASE:
|
|
case OPCODE_HS_FORK_PHASE:
|
|
case OPCODE_HS_JOIN_PHASE:
|
|
{
|
|
psInst->ui32NumOperands = 0;
|
|
psInst->ui32FirstSrc = 0;
|
|
break;
|
|
}
|
|
case OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT:
|
|
{
|
|
psInst->ui32NumOperands = 0;
|
|
psInst->ui32FirstSrc = 0;
|
|
break;
|
|
}
|
|
case OPCODE_SYNC:
|
|
{
|
|
psInst->ui32NumOperands = 0;
|
|
psInst->ui32FirstSrc = 0;
|
|
psInst->ui32SyncFlags = DecodeSyncFlags(*pui32Token);
|
|
break;
|
|
}
|
|
|
|
//1 operand
|
|
case OPCODE_EMIT_STREAM:
|
|
case OPCODE_CUT_STREAM:
|
|
case OPCODE_EMITTHENCUT_STREAM:
|
|
case OPCODE_CASE:
|
|
case OPCODE_SWITCH:
|
|
case OPCODE_LABEL:
|
|
{
|
|
psInst->ui32NumOperands = 1;
|
|
psInst->ui32FirstSrc = 0;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
|
|
if (eOpcode == OPCODE_CASE)
|
|
{
|
|
psInst->asOperands[0].iIntegerImmediate = 1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OPCODE_INTERFACE_CALL:
|
|
{
|
|
psInst->ui32NumOperands = 1;
|
|
psInst->ui32FirstSrc = 0;
|
|
psInst->ui32FuncIndexWithinInterface = pui32Token[ui32OperandOffset];
|
|
ui32OperandOffset++;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
|
|
break;
|
|
}
|
|
|
|
/* Floating point instruction decodes */
|
|
|
|
//Instructions with two operands go here
|
|
case OPCODE_MOV:
|
|
{
|
|
psInst->ui32NumOperands = 2;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
|
|
//Mov with an integer dest. If src is an immediate then it must be encoded as an integer.
|
|
if (psInst->asOperands[0].eMinPrecision == OPERAND_MIN_PRECISION_SINT_16 ||
|
|
psInst->asOperands[0].eMinPrecision == OPERAND_MIN_PRECISION_UINT_16)
|
|
{
|
|
psInst->asOperands[1].iIntegerImmediate = 1;
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_LOG:
|
|
case OPCODE_RSQ:
|
|
case OPCODE_EXP:
|
|
case OPCODE_SQRT:
|
|
case OPCODE_ROUND_PI:
|
|
case OPCODE_ROUND_NI:
|
|
case OPCODE_ROUND_Z:
|
|
case OPCODE_ROUND_NE:
|
|
case OPCODE_FRC:
|
|
case OPCODE_FTOU:
|
|
case OPCODE_FTOI:
|
|
case OPCODE_UTOF:
|
|
case OPCODE_ITOF:
|
|
case OPCODE_INEG:
|
|
case OPCODE_IMM_ATOMIC_ALLOC:
|
|
case OPCODE_IMM_ATOMIC_CONSUME:
|
|
case OPCODE_DMOV:
|
|
case OPCODE_DTOF:
|
|
case OPCODE_FTOD:
|
|
case OPCODE_DRCP:
|
|
case OPCODE_COUNTBITS:
|
|
case OPCODE_FIRSTBIT_HI:
|
|
case OPCODE_FIRSTBIT_LO:
|
|
case OPCODE_FIRSTBIT_SHI:
|
|
case OPCODE_BFREV:
|
|
case OPCODE_F32TOF16:
|
|
case OPCODE_F16TOF32:
|
|
case OPCODE_RCP:
|
|
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_NOT:
|
|
{
|
|
psInst->ui32NumOperands = 2;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
break;
|
|
}
|
|
|
|
//Instructions with three operands go here
|
|
case OPCODE_SINCOS:
|
|
{
|
|
psInst->ui32FirstSrc = 2;
|
|
//Intentional fall-through
|
|
}
|
|
case OPCODE_IMIN:
|
|
case OPCODE_MIN:
|
|
case OPCODE_UMIN:
|
|
case OPCODE_IMAX:
|
|
case OPCODE_MAX:
|
|
case OPCODE_UMAX:
|
|
case OPCODE_MUL:
|
|
case OPCODE_DIV:
|
|
case OPCODE_ADD:
|
|
case OPCODE_DP2:
|
|
case OPCODE_DP3:
|
|
case OPCODE_DP4:
|
|
case OPCODE_NE:
|
|
case OPCODE_OR:
|
|
case OPCODE_XOR:
|
|
case OPCODE_LT:
|
|
case OPCODE_IEQ:
|
|
case OPCODE_IADD:
|
|
case OPCODE_AND:
|
|
case OPCODE_GE:
|
|
case OPCODE_IGE:
|
|
case OPCODE_EQ:
|
|
case OPCODE_USHR:
|
|
case OPCODE_ISHL:
|
|
case OPCODE_ISHR:
|
|
case OPCODE_LD:
|
|
case OPCODE_ILT:
|
|
case OPCODE_INE:
|
|
case OPCODE_UGE:
|
|
case OPCODE_ULT:
|
|
case OPCODE_ATOMIC_AND:
|
|
case OPCODE_ATOMIC_IADD:
|
|
case OPCODE_ATOMIC_OR:
|
|
case OPCODE_ATOMIC_XOR:
|
|
case OPCODE_ATOMIC_IMAX:
|
|
case OPCODE_ATOMIC_IMIN:
|
|
case OPCODE_ATOMIC_UMAX:
|
|
case OPCODE_ATOMIC_UMIN:
|
|
case OPCODE_DADD:
|
|
case OPCODE_DMAX:
|
|
case OPCODE_DMIN:
|
|
case OPCODE_DMUL:
|
|
case OPCODE_DEQ:
|
|
case OPCODE_DGE:
|
|
case OPCODE_DLT:
|
|
case OPCODE_DNE:
|
|
case OPCODE_DDIV:
|
|
{
|
|
psInst->ui32NumOperands = 3;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
break;
|
|
}
|
|
//Instructions with four operands go here
|
|
case OPCODE_MAD:
|
|
case OPCODE_MOVC:
|
|
case OPCODE_IMAD:
|
|
case OPCODE_UDIV:
|
|
case OPCODE_LOD:
|
|
case OPCODE_SAMPLE:
|
|
case OPCODE_GATHER4:
|
|
case OPCODE_LD_MS:
|
|
case OPCODE_UBFE:
|
|
case OPCODE_IBFE:
|
|
case OPCODE_ATOMIC_CMP_STORE:
|
|
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_DMOVC:
|
|
case OPCODE_DFMA:
|
|
case OPCODE_IMUL:
|
|
{
|
|
psInst->ui32NumOperands = 4;
|
|
|
|
if (eOpcode == OPCODE_IMUL)
|
|
{
|
|
psInst->ui32FirstSrc = 2;
|
|
}
|
|
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[3]);
|
|
break;
|
|
}
|
|
case OPCODE_GATHER4_PO:
|
|
case OPCODE_SAMPLE_L:
|
|
case OPCODE_BFI:
|
|
case OPCODE_SWAPC:
|
|
case OPCODE_IMM_ATOMIC_CMP_EXCH:
|
|
{
|
|
psInst->ui32NumOperands = 5;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[3]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[4]);
|
|
break;
|
|
}
|
|
case OPCODE_GATHER4_C:
|
|
case OPCODE_SAMPLE_C:
|
|
case OPCODE_SAMPLE_C_LZ:
|
|
case OPCODE_SAMPLE_B:
|
|
{
|
|
psInst->ui32NumOperands = 5;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[3]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[4]);
|
|
|
|
/* sample_b is not a shadow sampler, others need flagging */
|
|
if (eOpcode != OPCODE_SAMPLE_B)
|
|
{
|
|
MarkTextureAsShadow(&psShader->sInfo,
|
|
psShader->asPhase[MAIN_PHASE].ppsDecl[0],
|
|
psShader->asPhase[MAIN_PHASE].pui32DeclCount[0], &psInst->asOperands[2]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case OPCODE_GATHER4_PO_C:
|
|
case OPCODE_SAMPLE_D:
|
|
{
|
|
psInst->ui32NumOperands = 6;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[3]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[4]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[5]);
|
|
|
|
/* sample_d is not a shadow sampler, others need flagging */
|
|
if (eOpcode != OPCODE_SAMPLE_D)
|
|
{
|
|
MarkTextureAsShadow(&psShader->sInfo,
|
|
psShader->asPhase[MAIN_PHASE].ppsDecl[0],
|
|
psShader->asPhase[MAIN_PHASE].pui32DeclCount[0], &psInst->asOperands[2]);
|
|
}
|
|
break;
|
|
}
|
|
case OPCODE_IF:
|
|
case OPCODE_BREAKC:
|
|
case OPCODE_CONTINUEC:
|
|
case OPCODE_RETC:
|
|
case OPCODE_DISCARD:
|
|
{
|
|
psInst->eBooleanTestType = DecodeInstrTestBool(*pui32Token);
|
|
psInst->ui32NumOperands = 1;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
break;
|
|
}
|
|
case OPCODE_CALLC:
|
|
{
|
|
psInst->eBooleanTestType = DecodeInstrTestBool(*pui32Token);
|
|
psInst->ui32NumOperands = 2;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
break;
|
|
}
|
|
case OPCODE_CUSTOMDATA:
|
|
{
|
|
psInst->ui32NumOperands = 0;
|
|
ui32TokenLength = pui32Token[1];
|
|
break;
|
|
}
|
|
case OPCODE_EVAL_CENTROID:
|
|
{
|
|
psInst->ui32NumOperands = 2;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
break;
|
|
}
|
|
case OPCODE_EVAL_SAMPLE_INDEX:
|
|
case OPCODE_EVAL_SNAPPED:
|
|
case OPCODE_STORE_UAV_TYPED:
|
|
case OPCODE_LD_UAV_TYPED:
|
|
case OPCODE_LD_RAW:
|
|
case OPCODE_STORE_RAW:
|
|
{
|
|
psInst->ui32NumOperands = 3;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
break;
|
|
}
|
|
case OPCODE_STORE_STRUCTURED:
|
|
case OPCODE_LD_STRUCTURED:
|
|
{
|
|
psInst->ui32NumOperands = 4;
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[3]);
|
|
break;
|
|
}
|
|
case OPCODE_RESINFO:
|
|
{
|
|
psInst->ui32NumOperands = 3;
|
|
|
|
psInst->eResInfoReturnType = DecodeResInfoReturnType(pui32Token[0]);
|
|
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[0]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[1]);
|
|
ui32OperandOffset += DecodeOperand(pui32Token + ui32OperandOffset, &psInst->asOperands[2]);
|
|
break;
|
|
}
|
|
case OPCODE_MSAD:
|
|
default:
|
|
{
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// For opcodes that sample textures, mark which samplers are used by each texture
|
|
{
|
|
uint32_t ui32TextureRegisterNumber;
|
|
uint32_t ui32SamplerRegisterNumber;
|
|
uint32_t bTextureSampleInstruction = 0;
|
|
switch (eOpcode)
|
|
{
|
|
case OPCODE_GATHER4:
|
|
// dest, coords, tex, sampler
|
|
ui32TextureRegisterNumber = 2;
|
|
ui32SamplerRegisterNumber = 3;
|
|
bTextureSampleInstruction = 1;
|
|
break;
|
|
case OPCODE_GATHER4_PO:
|
|
//dest, coords, offset, tex, sampler
|
|
ui32TextureRegisterNumber = 3;
|
|
ui32SamplerRegisterNumber = 4;
|
|
bTextureSampleInstruction = 1;
|
|
break;
|
|
case OPCODE_GATHER4_C:
|
|
//dest, coords, tex, sampler srcReferenceValue
|
|
ui32TextureRegisterNumber = 2;
|
|
ui32SamplerRegisterNumber = 3;
|
|
bTextureSampleInstruction = 1;
|
|
break;
|
|
case OPCODE_GATHER4_PO_C:
|
|
//dest, coords, offset, tex, sampler, srcReferenceValue
|
|
ui32TextureRegisterNumber = 3;
|
|
ui32SamplerRegisterNumber = 4;
|
|
bTextureSampleInstruction = 1;
|
|
break;
|
|
case OPCODE_SAMPLE:
|
|
case OPCODE_SAMPLE_L:
|
|
case OPCODE_SAMPLE_C:
|
|
case OPCODE_SAMPLE_C_LZ:
|
|
case OPCODE_SAMPLE_B:
|
|
case OPCODE_SAMPLE_D:
|
|
// dest, coords, tex, sampler [, reference]
|
|
ui32TextureRegisterNumber = 2;
|
|
ui32SamplerRegisterNumber = 3;
|
|
bTextureSampleInstruction = 1;
|
|
break;
|
|
}
|
|
|
|
if (bTextureSampleInstruction)
|
|
{
|
|
MarkTextureSamplerPair(&psShader->sInfo,
|
|
psShader->asPhase[MAIN_PHASE].ppsDecl[0],
|
|
psShader->asPhase[MAIN_PHASE].pui32DeclCount[0],
|
|
&psInst->asOperands[ui32TextureRegisterNumber],
|
|
&psInst->asOperands[ui32SamplerRegisterNumber],
|
|
&psShader->textureSamplerInfo);
|
|
}
|
|
}
|
|
|
|
UpdateOperandReferences(psShader, psInst);
|
|
|
|
return pui32Token + ui32TokenLength;
|
|
}
|
|
|
|
void BindTextureToSampler(ShaderData* psShader, uint32_t ui32TextureRegister, uint32_t ui32SamplerRegister)
|
|
{
|
|
ASSERT(ui32TextureRegister < MAX_RESOURCE_BINDINGS &&
|
|
(psShader->sInfo.aui32SamplerMap[ui32TextureRegister] == MAX_RESOURCE_BINDINGS ||
|
|
psShader->sInfo.aui32SamplerMap[ui32TextureRegister] == ui32SamplerRegister));
|
|
ASSERT(ui32SamplerRegister < MAX_RESOURCE_BINDINGS);
|
|
psShader->sInfo.aui32SamplerMap[ui32TextureRegister] = ui32SamplerRegister;
|
|
}
|
|
|
|
void UpdateOperandReferences(ShaderData* psShader, Instruction* psInst)
|
|
{
|
|
uint32_t ui32Operand;
|
|
const uint32_t ui32NumOperands = psInst->ui32NumOperands;
|
|
for (ui32Operand = 0; ui32Operand < ui32NumOperands; ++ui32Operand)
|
|
{
|
|
Operand* psOperand = &psInst->asOperands[ui32Operand];
|
|
if (psOperand->eType == OPERAND_TYPE_INPUT ||
|
|
psOperand->eType == OPERAND_TYPE_INPUT_CONTROL_POINT)
|
|
{
|
|
if (psOperand->iIndexDims == INDEX_2D)
|
|
{
|
|
if (psOperand->aui32ArraySizes[1] != 0)//gl_in[].gl_Position
|
|
{
|
|
psShader->abInputReferencedByInstruction[psOperand->ui32RegisterNumber] = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
psShader->abInputReferencedByInstruction[psOperand->ui32RegisterNumber] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (psInst->eOpcode)
|
|
{
|
|
case OPCODE_SAMPLE:
|
|
case OPCODE_SAMPLE_L:
|
|
case OPCODE_SAMPLE_C:
|
|
case OPCODE_SAMPLE_C_LZ:
|
|
case OPCODE_SAMPLE_B:
|
|
case OPCODE_SAMPLE_D:
|
|
case OPCODE_GATHER4:
|
|
case OPCODE_GATHER4_C:
|
|
BindTextureToSampler(psShader, psInst->asOperands[2].ui32RegisterNumber, psInst->asOperands[3].ui32RegisterNumber);
|
|
break;
|
|
case OPCODE_GATHER4_PO:
|
|
case OPCODE_GATHER4_PO_C:
|
|
BindTextureToSampler(psShader, psInst->asOperands[3].ui32RegisterNumber, psInst->asOperands[4].ui32RegisterNumber);
|
|
break;
|
|
}
|
|
}
|
|
|
|
const uint32_t* DecodeShaderPhase(const uint32_t* pui32Tokens,
|
|
ShaderData* psShader,
|
|
const uint32_t ui32Phase)
|
|
{
|
|
const uint32_t* pui32CurrentToken = pui32Tokens;
|
|
const uint32_t ui32ShaderLength = psShader->ui32ShaderLength;
|
|
const uint32_t ui32InstanceIndex = psShader->asPhase[ui32Phase].ui32InstanceCount;
|
|
|
|
Instruction* psInst;
|
|
|
|
//Declarations
|
|
Declaration* psDecl;
|
|
|
|
//Using ui32ShaderLength as the declaration and instruction count
|
|
//will allocate more than enough memory. Avoids having to
|
|
//traverse the entire shader just to get the real counts.
|
|
|
|
psDecl = hlslcc_malloc(sizeof(Declaration) * ui32ShaderLength);
|
|
psShader->asPhase[ui32Phase].ppsDecl[ui32InstanceIndex] = psDecl;
|
|
psShader->asPhase[ui32Phase].pui32DeclCount[ui32InstanceIndex] = 0;
|
|
|
|
psShader->asPhase[ui32Phase].ui32InstanceCount++;
|
|
|
|
while (1) //Keep going until we reach the first non-declaration token, or the end of the shader.
|
|
{
|
|
const uint32_t* pui32Result = DecodeDeclaration(psShader, pui32CurrentToken, psDecl);
|
|
|
|
if (pui32Result)
|
|
{
|
|
pui32CurrentToken = pui32Result;
|
|
psShader->asPhase[ui32Phase].pui32DeclCount[ui32InstanceIndex]++;
|
|
psDecl++;
|
|
|
|
if (pui32CurrentToken >= (psShader->pui32FirstToken + ui32ShaderLength))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//Instructions
|
|
psInst = hlslcc_malloc(sizeof(Instruction) * ui32ShaderLength);
|
|
psShader->asPhase[ui32Phase].ppsInst[ui32InstanceIndex] = psInst;
|
|
psShader->asPhase[ui32Phase].pui32InstCount[ui32InstanceIndex] = 0;
|
|
|
|
while (pui32CurrentToken < (psShader->pui32FirstToken + ui32ShaderLength))
|
|
{
|
|
const uint32_t* nextInstr = DeocdeInstruction(pui32CurrentToken, psInst, psShader);
|
|
|
|
#ifdef _DEBUG
|
|
if (nextInstr == pui32CurrentToken)
|
|
{
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
if (psInst->eOpcode == OPCODE_HS_FORK_PHASE)
|
|
{
|
|
return pui32CurrentToken;
|
|
}
|
|
else if (psInst->eOpcode == OPCODE_HS_JOIN_PHASE)
|
|
{
|
|
return pui32CurrentToken;
|
|
}
|
|
pui32CurrentToken = nextInstr;
|
|
psShader->asPhase[ui32Phase].pui32InstCount[ui32InstanceIndex]++;
|
|
|
|
psInst++;
|
|
}
|
|
|
|
return pui32CurrentToken;
|
|
}
|
|
|
|
void AllocateHullPhaseArrays(const uint32_t* pui32Tokens,
|
|
ShaderData* psShader,
|
|
uint32_t ui32Phase,
|
|
OPCODE_TYPE ePhaseOpcode)
|
|
{
|
|
const uint32_t* pui32CurrentToken = pui32Tokens;
|
|
const uint32_t ui32ShaderLength = psShader->ui32ShaderLength;
|
|
uint32_t ui32InstanceCount = 0;
|
|
|
|
while (1) //Keep going until we reach the first non-declaration token, or the end of the shader.
|
|
{
|
|
uint32_t ui32TokenLength = DecodeInstructionLength(*pui32CurrentToken);
|
|
const OPCODE_TYPE eOpcode = DecodeOpcodeType(*pui32CurrentToken);
|
|
|
|
if (eOpcode == OPCODE_CUSTOMDATA)
|
|
{
|
|
ui32TokenLength = pui32CurrentToken[1];
|
|
}
|
|
|
|
pui32CurrentToken = pui32CurrentToken + ui32TokenLength;
|
|
|
|
if (eOpcode == ePhaseOpcode)
|
|
{
|
|
ui32InstanceCount++;
|
|
}
|
|
|
|
if (pui32CurrentToken >= (psShader->pui32FirstToken + ui32ShaderLength))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ui32InstanceCount)
|
|
{
|
|
psShader->asPhase[ui32Phase].pui32DeclCount = hlslcc_malloc(sizeof(uint32_t) * ui32InstanceCount);
|
|
psShader->asPhase[ui32Phase].ppsDecl = hlslcc_malloc(sizeof(Declaration*) * ui32InstanceCount);
|
|
psShader->asPhase[ui32Phase].pui32DeclCount[0] = 0;
|
|
|
|
psShader->asPhase[ui32Phase].pui32InstCount = hlslcc_malloc(sizeof(uint32_t) * ui32InstanceCount);
|
|
psShader->asPhase[ui32Phase].ppsInst = hlslcc_malloc(sizeof(Instruction*) * ui32InstanceCount);
|
|
psShader->asPhase[ui32Phase].pui32InstCount[0] = 0;
|
|
}
|
|
}
|
|
|
|
const uint32_t* DecodeHullShader(const uint32_t* pui32Tokens, ShaderData* psShader)
|
|
{
|
|
const uint32_t* pui32CurrentToken = pui32Tokens;
|
|
const uint32_t ui32ShaderLength = psShader->ui32ShaderLength;
|
|
Declaration* psDecl;
|
|
|
|
psDecl = hlslcc_malloc(sizeof(Declaration) * ui32ShaderLength);
|
|
|
|
psShader->asPhase[HS_GLOBAL_DECL].ppsInst = 0;
|
|
psShader->asPhase[HS_GLOBAL_DECL].ppsDecl = hlslcc_malloc(sizeof(Declaration*));
|
|
psShader->asPhase[HS_GLOBAL_DECL].ppsDecl[0] = psDecl;
|
|
psShader->asPhase[HS_GLOBAL_DECL].pui32DeclCount = hlslcc_malloc(sizeof(uint32_t));
|
|
psShader->asPhase[HS_GLOBAL_DECL].pui32DeclCount[0] = 0;
|
|
psShader->asPhase[HS_GLOBAL_DECL].ui32InstanceCount = 1;
|
|
|
|
AllocateHullPhaseArrays(pui32Tokens, psShader, HS_CTRL_POINT_PHASE, OPCODE_HS_CONTROL_POINT_PHASE);
|
|
AllocateHullPhaseArrays(pui32Tokens, psShader, HS_FORK_PHASE, OPCODE_HS_FORK_PHASE);
|
|
AllocateHullPhaseArrays(pui32Tokens, psShader, HS_JOIN_PHASE, OPCODE_HS_JOIN_PHASE);
|
|
|
|
//Keep going until we have done all phases or the end of the shader.
|
|
while (1)
|
|
{
|
|
const uint32_t* pui32Result = DecodeDeclaration(psShader, pui32CurrentToken, psDecl);
|
|
|
|
if (pui32Result)
|
|
{
|
|
pui32CurrentToken = pui32Result;
|
|
|
|
if (psDecl->eOpcode == OPCODE_HS_CONTROL_POINT_PHASE)
|
|
{
|
|
pui32CurrentToken = DecodeShaderPhase(pui32CurrentToken, psShader, HS_CTRL_POINT_PHASE);
|
|
}
|
|
else if (psDecl->eOpcode == OPCODE_HS_FORK_PHASE)
|
|
{
|
|
pui32CurrentToken = DecodeShaderPhase(pui32CurrentToken, psShader, HS_FORK_PHASE);
|
|
}
|
|
else if (psDecl->eOpcode == OPCODE_HS_JOIN_PHASE)
|
|
{
|
|
pui32CurrentToken = DecodeShaderPhase(pui32CurrentToken, psShader, HS_JOIN_PHASE);
|
|
}
|
|
else
|
|
{
|
|
psDecl++;
|
|
psShader->asPhase[HS_GLOBAL_DECL].pui32DeclCount[0]++;
|
|
}
|
|
|
|
if (pui32CurrentToken >= (psShader->pui32FirstToken + ui32ShaderLength))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return pui32CurrentToken;
|
|
}
|
|
|
|
void Decode(const uint32_t* pui32Tokens, ShaderData* psShader)
|
|
{
|
|
const uint32_t* pui32CurrentToken = pui32Tokens;
|
|
const uint32_t ui32ShaderLength = pui32Tokens[1];
|
|
|
|
psShader->ui32MajorVersion = DecodeProgramMajorVersion(*pui32CurrentToken);
|
|
psShader->ui32MinorVersion = DecodeProgramMinorVersion(*pui32CurrentToken);
|
|
psShader->eShaderType = DecodeShaderType(*pui32CurrentToken);
|
|
|
|
pui32CurrentToken++;//Move to shader length
|
|
psShader->ui32ShaderLength = ui32ShaderLength;
|
|
pui32CurrentToken++;//Move to after shader length (usually a declaration)
|
|
|
|
psShader->pui32FirstToken = pui32Tokens;
|
|
|
|
if (psShader->eShaderType == HULL_SHADER)
|
|
{
|
|
pui32CurrentToken = DecodeHullShader(pui32CurrentToken, psShader);
|
|
return;
|
|
}
|
|
|
|
psShader->asPhase[MAIN_PHASE].ui32InstanceCount = 0;
|
|
psShader->asPhase[MAIN_PHASE].pui32DeclCount = hlslcc_malloc(sizeof(uint32_t));
|
|
psShader->asPhase[MAIN_PHASE].ppsDecl = hlslcc_malloc(sizeof(Declaration*));
|
|
psShader->asPhase[MAIN_PHASE].pui32DeclCount[0] = 0;
|
|
|
|
psShader->asPhase[MAIN_PHASE].pui32InstCount = hlslcc_malloc(sizeof(uint32_t));
|
|
psShader->asPhase[MAIN_PHASE].ppsInst = hlslcc_malloc(sizeof(Instruction*));
|
|
psShader->asPhase[MAIN_PHASE].pui32InstCount[0] = 0;
|
|
|
|
DecodeShaderPhase(pui32CurrentToken, psShader, MAIN_PHASE);
|
|
}
|
|
|
|
ShaderData* DecodeDXBC(uint32_t* data)
|
|
{
|
|
ShaderData* psShader;
|
|
DXBCContainerHeader* header = (DXBCContainerHeader*)data;
|
|
uint32_t i;
|
|
uint32_t chunkCount;
|
|
uint32_t* chunkOffsets;
|
|
ReflectionChunks refChunks;
|
|
uint32_t* shaderChunk = 0;
|
|
|
|
if (header->fourcc != FOURCC_DXBC)
|
|
{
|
|
//Could be SM1/2/3. If the shader type token
|
|
//looks valid then we continue
|
|
uint32_t type = DecodeShaderTypeDX9(data[0]);
|
|
|
|
if (type != INVALID_SHADER)
|
|
{
|
|
return DecodeDX9BC(data);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
refChunks.pui32Inputs = NULL;
|
|
refChunks.pui32Interfaces = NULL;
|
|
refChunks.pui32Outputs = NULL;
|
|
refChunks.pui32Resources = NULL;
|
|
refChunks.pui32Inputs11 = NULL;
|
|
refChunks.pui32Outputs11 = NULL;
|
|
refChunks.pui32OutputsWithStreams = NULL;
|
|
refChunks.pui32PatchConstants = NULL;
|
|
refChunks.pui32Effects10Data = NULL;
|
|
|
|
chunkOffsets = (uint32_t*)(header + 1);
|
|
|
|
chunkCount = header->chunkCount;
|
|
|
|
for (i = 0; i < chunkCount; ++i)
|
|
{
|
|
uint32_t offset = chunkOffsets[i];
|
|
|
|
DXBCChunkHeader* chunk = (DXBCChunkHeader*)((char*)data + offset);
|
|
|
|
switch (chunk->fourcc)
|
|
{
|
|
case FOURCC_ISGN:
|
|
{
|
|
refChunks.pui32Inputs = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_ISG1:
|
|
{
|
|
refChunks.pui32Inputs11 = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_RDEF:
|
|
{
|
|
refChunks.pui32Resources = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_IFCE:
|
|
{
|
|
refChunks.pui32Interfaces = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_OSGN:
|
|
{
|
|
refChunks.pui32Outputs = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_OSG1:
|
|
{
|
|
refChunks.pui32Outputs11 = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_OSG5:
|
|
{
|
|
refChunks.pui32OutputsWithStreams = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_SHDR:
|
|
case FOURCC_SHEX:
|
|
{
|
|
shaderChunk = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_PSGN:
|
|
{
|
|
refChunks.pui32PatchConstants = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
case FOURCC_FX10:
|
|
{
|
|
refChunks.pui32Effects10Data = (uint32_t*)(chunk + 1);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (shaderChunk)
|
|
{
|
|
uint32_t ui32MajorVersion;
|
|
uint32_t ui32MinorVersion;
|
|
|
|
psShader = hlslcc_calloc(1, sizeof(ShaderData));
|
|
|
|
ui32MajorVersion = DecodeProgramMajorVersion(*shaderChunk);
|
|
ui32MinorVersion = DecodeProgramMinorVersion(*shaderChunk);
|
|
|
|
LoadShaderInfo(ui32MajorVersion,
|
|
ui32MinorVersion,
|
|
&refChunks,
|
|
&psShader->sInfo);
|
|
|
|
Decode(shaderChunk, psShader);
|
|
|
|
return psShader;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|