Initial commit

2021-03-05 11:26:34 -08:00
commit a10351f38d
27091 changed files with 5521199 additions and 0 deletions
@@ -0,0 +1,21 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef DEBUG_H_
+#define DEBUG_H_
+
+#ifdef _DEBUG
+#include "assert.h"
+#define ASSERT(expr) CustomAssert(expr)
+static void CustomAssert(int expression)
+{
+    if(!expression)
+    {
+        assert(0);
+    }
+}
+#else
+#define ASSERT(expr)
+#endif
+
+#endif
@@ -0,0 +1,21 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef DECODE_H
+#define DECODE_H
+
+#include "internal_includes/structs.h"
+
+Shader* DecodeDXBC(uint32_t* data);
+
+//You don't need to call this directly because DecodeDXBC
+//will call DecodeDX9BC if the shader looks
+//like it is SM1/2/3.
+Shader* DecodeDX9BC(const uint32_t* pui32Tokens);
+
+void UpdateDeclarationReferences(Shader* psShader, Declaration* psDeclaration);
+void UpdateInstructionReferences(Shader* psShader, Instruction* psInstruction);
+
+#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))
+
+#endif
@@ -0,0 +1,35 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+#ifndef HLSLCC_TOOLKIT_DECLARATION_H
+#define HLSLCC_TOOLKIT_DECLARATION_H
+
+#include "hlslcc.h"
+#include "bstrlib.h"
+#include "internal_includes/structs.h"
+
+#include <stdbool.h>
+
+// Check if "src" type can be assigned directly to the "dest" type.
+bool DoAssignmentDataTypesMatch(SHADER_VARIABLE_TYPE dest, SHADER_VARIABLE_TYPE src);
+
+// Returns the constructor needed depending on the type, the number of components and the use of precision qualifier.
+const char * GetConstructorForTypeGLSL(HLSLCrossCompilerContext* psContext, const SHADER_VARIABLE_TYPE eType, const int components, bool useGLSLPrecision);
+
+// Transform from a variable type to a shader variable flag.
+uint32_t SVTTypeToFlag(const SHADER_VARIABLE_TYPE eType);
+
+// Transform from a shader variable flag to a shader variable type.
+SHADER_VARIABLE_TYPE TypeFlagsToSVTType(const uint32_t typeflags);
+
+// Check if the "src" type can be casted using a constructor to the "dest" type (without bitcasting).
+bool CanDoDirectCast(SHADER_VARIABLE_TYPE src, SHADER_VARIABLE_TYPE dest);
+
+// Returns the bitcast operation needed to assign the "src" type to the "dest" type
+const char* GetBitcastOp(SHADER_VARIABLE_TYPE src, SHADER_VARIABLE_TYPE dest);
+
+// Check if the register number is part of the ones we used for signaling GMEM input
+bool IsGmemReservedSlot(FRAMEBUFFER_FETCH_TYPE type, const uint32_t regNumber);
+
+// Return the name of an auxiliary variable used to save intermediate values to bypass driver issues
+const char * GetAuxArgumentName(const SHADER_VARIABLE_TYPE varType);
+
+#endif
@@ -0,0 +1,16 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <stdlib.h>
+#endif
+#include <AzCore/PlatformDef.h>
+
+AZ_PUSH_DISABLE_WARNING(4232, "-Wunknown-warning-option") // address of malloc/free/calloc/realloc are not static
+void* (*hlslcc_malloc)(size_t size) = malloc;
+void* (*hlslcc_calloc)(size_t num,size_t size) = calloc;
+void (*hlslcc_free)(void *p) = free;
+void* (*hlslcc_realloc)(void *p,size_t size) = realloc;
+AZ_POP_DISABLE_WARNING
@@ -0,0 +1,15 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef __HLSCC_MALLOC_H
+#define __HLSCC_MALLOC_H
+
+extern void* (*hlslcc_malloc)(size_t size);
+extern void* (* hlslcc_calloc)(size_t num, size_t size);
+extern void (* hlslcc_free)(void* p);
+extern void* (* hlslcc_realloc)(void* p, size_t size);
+
+#define bstr__alloc hlslcc_malloc
+#define bstr__free hlslcc_free
+#define bstr__realloc hlslcc_realloc
+#endif
@@ -0,0 +1,242 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef LANGUAGES_H
+#define LANGUAGES_H
+
+#include "hlslcc.h"
+
+static int InOutSupported(const GLLang eLang)
+{
+    if(eLang == LANG_ES_100 || eLang == LANG_120)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+static int WriteToFragData(const GLLang eLang)
+{
+    if(eLang == LANG_ES_100 || eLang == LANG_120)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int ShaderBitEncodingSupported(const GLLang eLang)
+{
+    if( eLang != LANG_ES_300 &&
+        eLang != LANG_ES_310 &&
+        eLang < LANG_330)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+static int HaveOverloadedTextureFuncs(const GLLang eLang)
+{
+    if(eLang == LANG_ES_100 || eLang == LANG_120)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+//Only enable for ES.
+//Not present in 120, ignored in other desktop languages.
+static int HavePrecisionQualifers(const GLLang eLang)
+{
+    if(eLang >= LANG_ES_100 && eLang <= LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+//Only on vertex inputs and pixel outputs.
+static int HaveLimitedInOutLocationQualifier(const GLLang eLang)
+{
+    if(eLang >= LANG_330 || eLang == LANG_ES_300 || eLang == LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveInOutLocationQualifier(const GLLang eLang,const struct GlExtensions *extensions)
+{
+    if(eLang >= LANG_410 || eLang == LANG_ES_310 || (extensions && ((GlExtensions*)extensions)->ARB_explicit_attrib_location))
+    {
+        return 1;
+    }
+    return 0;
+}
+
+//layout(binding = X) uniform {uniformA; uniformB;}
+//layout(location = X) uniform uniform_name;
+static int HaveUniformBindingsAndLocations(const GLLang eLang,const struct GlExtensions *extensions)
+{
+    if(eLang >= LANG_430 || eLang == LANG_ES_310 || (extensions && ((GlExtensions*)extensions)->ARB_explicit_uniform_location))
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int DualSourceBlendSupported(const GLLang eLang)
+{
+    if(eLang >= LANG_330)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int SubroutinesSupported(const GLLang eLang)
+{
+    if(eLang >= LANG_400)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+//Before 430, flat/smooth/centroid/noperspective must match
+//between fragment and its previous stage.
+//HLSL bytecode only tells us the interpolation in pixel shader.
+static int PixelInterpDependency(const GLLang eLang)
+{
+    if(eLang < LANG_430)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveUVec(const GLLang eLang)
+{
+    switch(eLang)
+    {
+    case LANG_ES_100:
+    case LANG_120:
+        return 0;
+    default:
+        break;
+    }
+    return 1;
+}
+
+static int HaveGather(const GLLang eLang)
+{
+    if(eLang >= LANG_400 || eLang == LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveGatherNonConstOffset(const GLLang eLang)
+{
+    if(eLang >= LANG_420 || eLang == LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+
+static int HaveQueryLod(const GLLang eLang)
+{
+    if(eLang >= LANG_400)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveQueryLevels(const GLLang eLang)
+{
+    if(eLang >= LANG_430)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+
+static int HaveAtomicCounter(const GLLang eLang)
+{
+    if(eLang >= LANG_420 || eLang == LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveAtomicMem(const GLLang eLang)
+{
+    if(eLang >= LANG_430)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveCompute(const GLLang eLang)
+{
+    if(eLang >= LANG_430 || eLang == LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveImageLoadStore(const GLLang eLang)
+{
+    if(eLang >= LANG_420 || eLang == LANG_ES_310)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int EmulateDepthClamp(const GLLang eLang)
+{
+    if (eLang >= LANG_ES_300 && eLang < LANG_120) //Requires gl_FragDepth available in fragment shader
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int HaveNoperspectiveInterpolation(const GLLang eLang)
+{
+    if (eLang >= LANG_330)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int EarlyDepthTestSupported(const GLLang eLang)
+{
+    if ((eLang > LANG_410) || (eLang == LANG_ES_310))
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static int StorageBlockBindingSupported(const GLLang eLang)
+{
+    if (eLang >= LANG_430)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+
+#endif
@@ -0,0 +1,42 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef REFLECT_H
+#define REFLECT_H
+
+#include "hlslcc.h"
+
+ResourceGroup ResourceTypeToResourceGroup(ResourceType);
+
+int GetResourceFromBindingPoint(const ResourceGroup eGroup, const uint32_t ui32BindPoint, const ShaderInfo* psShaderInfo, ResourceBinding** ppsOutBinding);
+
+void GetConstantBufferFromBindingPoint(const ResourceGroup eGroup, const uint32_t ui32BindPoint, const ShaderInfo* psShaderInfo, ConstantBuffer** ppsConstBuf);
+
+int GetInterfaceVarFromOffset(uint32_t ui32Offset, ShaderInfo* psShaderInfo, ShaderVar** ppsShaderVar);
+
+int GetInputSignatureFromRegister(const uint32_t ui32Register, const ShaderInfo* psShaderInfo, InOutSignature** ppsOut);
+int GetOutputSignatureFromRegister(const uint32_t ui32Register, const uint32_t ui32Stream, const uint32_t ui32CompMask, ShaderInfo* psShaderInfo, InOutSignature** ppsOut);
+
+int GetOutputSignatureFromSystemValue(SPECIAL_NAME eSystemValueType, uint32_t ui32SemanticIndex, ShaderInfo* psShaderInfo, InOutSignature** ppsOut);
+
+int GetShaderVarFromOffset(const uint32_t ui32Vec4Offset, const uint32_t* pui32Swizzle, ConstantBuffer* psCBuf, ShaderVarType** ppsShaderVar, int32_t* pi32Index, int32_t* pi32Rebase);
+
+typedef struct
+{
+    uint32_t* pui32Inputs;
+    uint32_t* pui32Outputs;
+    uint32_t* pui32Resources;
+    uint32_t* pui32Interfaces;
+    uint32_t* pui32Inputs11;
+    uint32_t* pui32Outputs11;
+    uint32_t* pui32OutputsWithStreams;
+} ReflectionChunks;
+
+void LoadShaderInfo(const uint32_t ui32MajorVersion, const uint32_t ui32MinorVersion, const ReflectionChunks* psChunks, ShaderInfo* psInfo);
+
+void LoadD3D9ConstantTable(const char* data, ShaderInfo* psInfo);
+
+void FreeShaderInfo(ShaderInfo* psShaderInfo);
+
+#endif
+
@@ -0,0 +1,36 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef HLSLCC_SHADER_LIMITS_H
+#define HLSLCC_SHADER_LIMITS_H
+
+static enum
+{
+    MAX_SHADER_VEC4_OUTPUT = 512
+};
+static enum
+{
+    MAX_SHADER_VEC4_INPUT = 512
+};
+static enum
+{
+    MAX_TEXTURES = 128
+};
+static enum
+{
+    MAX_FORK_PHASES = 2
+};
+static enum
+{
+    MAX_FUNCTION_BODIES = 1024
+};
+static enum
+{
+    MAX_CLASS_TYPES = 1024
+};
+static enum
+{
+    MAX_FUNCTION_POINTERS = 128
+};
+
+#endif
@@ -0,0 +1,374 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef STRUCTS_H
+#define STRUCTS_H
+
+#include "hlslcc.h"
+#include "bstrlib.h"
+
+#include "internal_includes/tokens.h"
+#include "internal_includes/reflect.h"
+
+enum
+{
+    MAX_SUB_OPERANDS = 3
+};
+
+typedef struct Operand_TAG
+{
+    int iExtended;
+    OPERAND_TYPE eType;
+    OPERAND_MODIFIER eModifier;
+    OPERAND_MIN_PRECISION eMinPrecision;
+    int iIndexDims;
+    int indexRepresentation[4];
+    int writeMask;
+    int iGSInput;
+    int iWriteMaskEnabled;
+
+    int iNumComponents;
+
+    OPERAND_4_COMPONENT_SELECTION_MODE eSelMode;
+    uint32_t ui32CompMask;
+    uint32_t ui32Swizzle;
+    uint32_t aui32Swizzle[4];
+
+    uint32_t aui32ArraySizes[3];
+    uint32_t ui32RegisterNumber;
+    //If eType is OPERAND_TYPE_IMMEDIATE32
+    float afImmediates[4];
+    //If eType is OPERAND_TYPE_IMMEDIATE64
+    double adImmediates[4];
+
+    int iIntegerImmediate;
+
+    SPECIAL_NAME eSpecialName;
+    char pszSpecialName[64];
+
+    OPERAND_INDEX_REPRESENTATION eIndexRep[3];
+
+    struct Operand_TAG* psSubOperand[MAX_SUB_OPERANDS];
+
+    //One type for each component.
+    SHADER_VARIABLE_TYPE aeDataType[4];
+
+#ifdef _DEBUG
+    uint64_t id;
+#endif
+} Operand;
+
+typedef struct Instruction_TAG
+{
+    OPCODE_TYPE eOpcode;
+    INSTRUCTION_TEST_BOOLEAN eBooleanTestType;
+    COMPARISON_DX9 eDX9TestType;
+    uint32_t ui32SyncFlags;
+    uint32_t ui32NumOperands;
+    uint32_t ui32FirstSrc;
+    Operand asOperands[6];
+    uint32_t bSaturate;
+    uint32_t ui32FuncIndexWithinInterface;
+    RESINFO_RETURN_TYPE eResInfoReturnType;
+
+    int bAddressOffset;
+    int iUAddrOffset;
+    int iVAddrOffset;
+    int iWAddrOffset;
+    RESOURCE_RETURN_TYPE xType, yType, zType, wType;
+    RESOURCE_DIMENSION eResDim;
+
+#ifdef _DEBUG
+    uint64_t id;
+#endif
+} Instruction;
+
+enum
+{
+    MAX_IMMEDIATE_CONST_BUFFER_VEC4_SIZE = 1024
+};
+
+typedef struct ICBVec4_TAG
+{
+    uint32_t a;
+    uint32_t b;
+    uint32_t c;
+    uint32_t d;
+} ICBVec4;
+
+typedef struct Declaration_TAG
+{
+    OPCODE_TYPE eOpcode;
+
+    uint32_t ui32NumOperands;
+
+    Operand asOperands[2];
+
+    ICBVec4 asImmediateConstBuffer[MAX_IMMEDIATE_CONST_BUFFER_VEC4_SIZE];
+    //The declaration can set one of these
+    //values depending on the opcode.
+    union
+    {
+        uint32_t ui32GlobalFlags;
+        uint32_t ui32NumTemps;
+        RESOURCE_DIMENSION eResourceDimension;
+        CONSTANT_BUFFER_ACCESS_PATTERN eCBAccessPattern;
+        INTERPOLATION_MODE eInterpolation;
+        PRIMITIVE_TOPOLOGY eOutputPrimitiveTopology;
+        PRIMITIVE eInputPrimitive;
+        uint32_t ui32MaxOutputVertexCount;
+        TESSELLATOR_DOMAIN eTessDomain;
+        TESSELLATOR_PARTITIONING eTessPartitioning;
+        TESSELLATOR_OUTPUT_PRIMITIVE eTessOutPrim;
+        uint32_t aui32WorkGroupSize[3];
+        //Fork phase index followed by the instance count.
+        uint32_t aui32HullPhaseInstanceInfo[2];
+        float fMaxTessFactor;
+        uint32_t ui32IndexRange;
+        uint32_t ui32GSInstanceCount;
+
+        struct Interface_TAG
+        {
+            uint32_t ui32InterfaceID;
+            uint32_t ui32NumFuncTables;
+            uint32_t ui32ArraySize;
+        } interface;
+    } value;
+
+    struct UAV_TAG
+    {
+        uint32_t ui32GloballyCoherentAccess;
+        uint32_t ui32BufferSize;
+        uint8_t bCounter;
+        RESOURCE_RETURN_TYPE Type;
+    } sUAV;
+
+    struct TGSM_TAG
+    {
+        uint32_t ui32Stride;
+        uint32_t ui32Count;
+    } sTGSM;
+
+    struct IndexableTemp_TAG
+    {
+        uint32_t ui32RegIndex;
+        uint32_t ui32RegCount;
+        uint32_t ui32RegComponentSize;
+    } sIdxTemp;
+
+    uint32_t ui32TableLength;
+
+    uint32_t ui32TexReturnType;
+} Declaration;
+
+enum
+{
+    MAX_TEMP_VEC4 = 512
+};
+
+enum
+{
+    MAX_GROUPSHARED = 8
+};
+
+enum
+{
+    MAX_DX9_IMMCONST = 256
+};
+
+typedef struct Shader_TAG
+{
+    uint32_t ui32MajorVersion;
+    uint32_t ui32MinorVersion;
+    SHADER_TYPE eShaderType;
+
+    GLLang eTargetLanguage;
+    const struct GlExtensions *extensions;
+
+    int fp64;
+
+    //DWORDs in program code, including version and length tokens.
+    uint32_t ui32ShaderLength;
+
+    uint32_t ui32DeclCount;
+    Declaration* psDecl;
+
+    //Instruction* functions;//non-main subroutines
+
+    uint32_t aui32FuncTableToFuncPointer[MAX_FUNCTION_TABLES];//FIXME dynamic alloc
+    uint32_t aui32FuncBodyToFuncTable[MAX_FUNCTION_BODIES];
+
+    struct
+    {
+        uint32_t aui32FuncBodies[MAX_FUNCTION_BODIES];
+    }funcTable[MAX_FUNCTION_TABLES];
+
+    struct
+    {
+        uint32_t aui32FuncTables[MAX_FUNCTION_TABLES];
+        uint32_t ui32NumBodiesPerTable;
+    }funcPointer[MAX_FUNCTION_POINTERS];
+
+    uint32_t ui32NextClassFuncName[MAX_CLASS_TYPES];
+
+    uint32_t ui32InstCount;
+    Instruction* psInst;
+
+    const uint32_t* pui32FirstToken;//Reference for calculating current position in token stream.
+
+    //Hull shader declarations and instructions.
+    //psDecl, psInst are null for hull shaders.
+    uint32_t ui32HSDeclCount;
+    Declaration* psHSDecl;
+
+    uint32_t ui32HSControlPointDeclCount;
+    Declaration* psHSControlPointPhaseDecl;
+
+    uint32_t ui32HSControlPointInstrCount;
+    Instruction* psHSControlPointPhaseInstr;
+
+    uint32_t ui32ForkPhaseCount;
+
+    uint32_t aui32HSForkDeclCount[MAX_FORK_PHASES];
+    Declaration* apsHSForkPhaseDecl[MAX_FORK_PHASES];
+
+    uint32_t aui32HSForkInstrCount[MAX_FORK_PHASES];
+    Instruction* apsHSForkPhaseInstr[MAX_FORK_PHASES];
+
+    uint32_t ui32HSJoinDeclCount;
+    Declaration* psHSJoinPhaseDecl;
+
+    uint32_t ui32HSJoinInstrCount;
+    Instruction* psHSJoinPhaseInstr;
+
+    ShaderInfo sInfo;
+
+    int abScalarInput[MAX_SHADER_VEC4_INPUT];
+
+    int aIndexedOutput[MAX_SHADER_VEC4_OUTPUT];
+
+    int aIndexedInput[MAX_SHADER_VEC4_INPUT];
+    int aIndexedInputParents[MAX_SHADER_VEC4_INPUT];
+
+    RESOURCE_DIMENSION aeResourceDims[MAX_TEXTURES];
+
+    int aiInputDeclaredSize[MAX_SHADER_VEC4_INPUT];
+
+    int aiOutputDeclared[MAX_SHADER_VEC4_OUTPUT];
+
+    //Does not track built-in inputs.
+    int abInputReferencedByInstruction[MAX_SHADER_VEC4_INPUT];
+
+    int aiOpcodeUsed[NUM_OPCODES];
+
+    uint32_t ui32CurrentVertexOutputStream;
+
+    uint32_t ui32NumDx9ImmConst;
+    uint32_t aui32Dx9ImmConstArrayRemap[MAX_DX9_IMMCONST];
+
+    ShaderVarType sGroupSharedVarType[MAX_GROUPSHARED];
+
+    SHADER_VARIABLE_TYPE aeCommonTempVecType[MAX_TEMP_VEC4];
+    uint32_t bUseTempCopy;
+    FRAMEBUFFER_FETCH_TYPE eGmemType;
+} Shader;
+
+/* CONFETTI NOTE: DAVID SROUR
+ * The following is super sketchy, but at the moment,
+ * there is no way to figure out the type of a resource
+ * since HLSL has only register sets for the following:
+ * bool, int4, float4, sampler.
+ * THIS CODE IS DUPLICATED FROM HLSLcc METAL.
+ * IF ANYTHING CHANGES, BOTH TRANSLATORS SHOULD HAVE THE CHANGE.
+ * TODO: CONSOLIDATE THE 2 HLSLcc PROJECTS.
+ */
+enum
+{
+    GMEM_FLOAT4_START_SLOT = 120
+};
+enum
+{
+    GMEM_FLOAT3_START_SLOT = 112
+};
+enum
+{
+    GMEM_FLOAT2_START_SLOT = 104
+};
+enum
+{
+    GMEM_FLOAT_START_SLOT = 96
+};
+
+enum
+{
+    GMEM_ARM_COLOR_SLOT = 93,
+    GMEM_ARM_DEPTH_SLOT = 94,
+    GMEM_ARM_STENCIL_SLOT = 95
+};
+
+/* CONFETTI NOTE: DAVID SROUR
+ * Following is the reserved slot for PLS extension (https://www.khronos.org/registry/gles/extensions/EXT/EXT_shader_pixel_local_storage.txt).
+ * It will get picked up when a RWStructuredBuffer resource is defined at the following reserved slot.
+ * Note that only one PLS struct can be present at a time otherwise the behavior is undefined.
+ *
+ * Types in the struct and their output conversion (each output variable will always be 4 bytes):
+ * float2   -> rg16f
+ * float3   -> r11f_g11f_b10f
+ * float4   -> rgba8
+ * uint     -> r32ui
+ * int2     -> rg16i
+ * int4     -> rgba8i
+ */
+enum
+{
+    GMEM_PLS_RO_SLOT = 60
+};                              // READ-ONLY
+enum
+{
+    GMEM_PLS_WO_SLOT = 61
+};                              // WRITE-ONLY
+enum
+{
+    GMEM_PLS_RW_SLOT = 62
+};                              // READ/WRITE
+
+static const uint32_t MAIN_PHASE = 0;
+static const uint32_t HS_FORK_PHASE = 1;
+static const uint32_t HS_CTRL_POINT_PHASE = 2;
+static const uint32_t HS_JOIN_PHASE = 3;
+enum
+{
+    NUM_PHASES = 4
+};
+
+enum
+{
+    MAX_COLOR_MRT = 8
+};
+
+enum
+{
+    INPUT_RENDERTARGET = 1 << 0,
+    OUTPUT_RENDERTARGET = 1 << 1
+};
+
+typedef struct HLSLCrossCompilerContext_TAG
+{
+    bstring glsl;
+    bstring earlyMain;//Code to be inserted at the start of main()
+    bstring postShaderCode[NUM_PHASES];//End of main or before emit()
+    bstring debugHeader;
+
+    bstring* currentGLSLString;//either glsl or earlyMain
+
+    int havePostShaderCode[NUM_PHASES];
+    uint32_t currentPhase;
+
+    uint32_t rendertargetUse[MAX_COLOR_MRT];
+
+    int indent;
+    unsigned int flags;
+    Shader* psShader;
+} HLSLCrossCompilerContext;
+
+#endif
@@ -0,0 +1,19 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TO_GLSL_DECLARATION_H
+#define TO_GLSL_DECLARATION_H
+
+#include "internal_includes/structs.h"
+
+void TranslateDeclaration(HLSLCrossCompilerContext* psContext, const Declaration* psDecl);
+
+char* GetDeclaredInputName(const HLSLCrossCompilerContext* psContext, const SHADER_TYPE eShaderType, const Operand* psOperand);
+char* GetDeclaredOutputName(const HLSLCrossCompilerContext* psContext, const SHADER_TYPE eShaderType, const Operand* psOperand, int* stream);
+
+//Hull shaders have multiple phases.
+//Each phase has its own temps.
+//Convert to global temps for GLSL.
+void ConsolidateHullTempVars(Shader* psShader);
+
+#endif
@@ -0,0 +1,18 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TO_GLSL_INSTRUCTION_H
+#define TO_GLSL_INSTRUCTION_H
+
+#include "internal_includes/structs.h"
+
+void TranslateInstruction(HLSLCrossCompilerContext* psContext, Instruction* psInst);
+
+//For each MOV temp, immediate; check to see if the next instruction
+//using that temp has an integer opcode. If so then the immediate value
+//is flaged as having an integer encoding.
+void MarkIntegerImmediates(HLSLCrossCompilerContext* psContext);
+
+void SetDataTypes(HLSLCrossCompilerContext* psContext, Instruction* psInst, const int32_t i32InstCount, SHADER_VARIABLE_TYPE* aeCommonTempVecType);
+
+#endif
@@ -0,0 +1,46 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TO_GLSL_OPERAND_H
+#define TO_GLSL_OPERAND_H
+
+#include "internal_includes/structs.h"
+
+void TranslateOperand(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32TOFlag);
+
+int GetMaxComponentFromComponentMask(const Operand* psOperand);
+void TranslateOperandIndex(HLSLCrossCompilerContext* psContext, const Operand* psOperand, int index);
+void TranslateOperandIndexMAD(HLSLCrossCompilerContext* psContext, const Operand* psOperand, int index, uint32_t multiply, uint32_t add);
+void TranslateVariableName(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32TOFlag, uint32_t* pui32IgnoreSwizzle);
+void TranslateOperandSwizzle(HLSLCrossCompilerContext* psContext, const Operand* psOperand);
+
+uint32_t GetNumSwizzleElements(const Operand* psOperand);
+void AddSwizzleUsingElementCount(HLSLCrossCompilerContext* psContext, uint32_t count);
+int GetFirstOperandSwizzle(HLSLCrossCompilerContext* psContext, const Operand* psOperand);
+uint32_t IsSwizzleReplacated(const Operand* psOperand);
+
+void TextureName(bstring output, Shader* psShader, const uint32_t ui32TextureRegister, const uint32_t ui32SamplerRegister, const int bCompare);
+void UAVName(bstring output, Shader* psShader, const uint32_t ui32RegisterNumber);
+void UniformBufferName(bstring output, Shader* psShader, const uint32_t ui32RegisterNumber);
+
+void ConvertToTextureName(bstring output, Shader* psShader, const char* szName, const char* szSamplerName, const int bCompare);
+void ConvertToUAVName(bstring output, Shader* psShader, const char* szOriginalUAVName);
+void ConvertToUniformBufferName(bstring output, Shader* psShader, const char* szConstantBufferName);
+
+void ShaderVarName(bstring output, Shader* psShader, const char* OriginalName);
+void ShaderVarFullName(bstring output, Shader* psShader, const ShaderVarType* psShaderVar);
+
+uint32_t ConvertOperandSwizzleToComponentMask(const Operand* psOperand);
+//Non-zero means the components overlap
+int CompareOperandSwizzles(const Operand* psOperandA, const Operand* psOperandB);
+
+SHADER_VARIABLE_TYPE GetOperandDataType(HLSLCrossCompilerContext* psContext, const Operand* psOperand);
+
+
+// NOTE: CODE DUPLICATION FROM HLSLcc METAL ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void TranslateGmemOperandSwizzleWithMask(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32ComponentMask, uint32_t gmemNumElements);
+uint32_t GetGmemInputResourceSlot(uint32_t const slotIn);
+uint32_t GetGmemInputResourceNumElements(uint32_t const slotIn);
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif
@@ -0,0 +1,16 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TO_METAL_DECLARATION_H
+#define TO_METAL_DECLARATION_H
+
+#include "internal_includes/structs.h"
+
+void TranslateDeclarationMETAL(HLSLCrossCompilerContext* psContext, const Declaration* psDecl);
+
+char* GetDeclaredInputNameMETAL(const HLSLCrossCompilerContext* psContext, const SHADER_TYPE eShaderType, const Operand* psOperand);
+char* GetDeclaredOutputNameMETAL(const HLSLCrossCompilerContext* psContext, const SHADER_TYPE eShaderType, const Operand* psOperand);
+
+const char* GetMangleSuffixMETAL(const SHADER_TYPE eShaderType);
+
+#endif
@@ -0,0 +1,18 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TO_METAL_INSTRUCTION_H
+#define TO_METAL_INSTRUCTION_H
+
+#include "internal_includes/structs.h"
+
+void TranslateInstructionMETAL(HLSLCrossCompilerContext* psContext, Instruction* psInst);
+
+//For each MOV temp, immediate; check to see if the next instruction
+//using that temp has an integer opcode. If so then the immediate value
+//is flaged as having an integer encoding.
+void MarkIntegerImmediatesMETAL(HLSLCrossCompilerContext* psContext);
+
+void SetDataTypesMETAL(HLSLCrossCompilerContext* psContext, Instruction* psInst, const int32_t i32InstCount, SHADER_VARIABLE_TYPE* aeCommonTempVecType);
+
+#endif
@@ -0,0 +1,38 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TO_METAL_OPERAND_H
+#define TO_METAL_OPERAND_H
+
+#include "internal_includes/structs.h"
+
+#define TO_FLAG_NONE    0x0
+#define TO_FLAG_INTEGER 0x1
+#define TO_FLAG_NAME_ONLY 0x2
+#define TO_FLAG_DECLARATION_NAME 0x4
+#define TO_FLAG_DESTINATION 0x8 //Operand is being written to by assignment.
+#define TO_FLAG_UNSIGNED_INTEGER 0x10
+#define TO_FLAG_DOUBLE 0x20
+#define TO_FLAG_FLOAT 0x40
+
+void TranslateOperandMETAL(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32TOFlag);
+
+int GetMaxComponentFromComponentMaskMETAL(const Operand* psOperand);
+void TranslateOperandMETALIndex(HLSLCrossCompilerContext* psContext, const Operand* psOperand, int index);
+void TranslateOperandMETALIndexMAD(HLSLCrossCompilerContext* psContext, const Operand* psOperand, int index, uint32_t multiply, uint32_t add);
+void TranslateVariableNameMETAL(HLSLCrossCompilerContext* psContext, const Operand* psOperand, uint32_t ui32TOFlag, uint32_t* pui32IgnoreSwizzle);
+void TranslateOperandMETALSwizzle(HLSLCrossCompilerContext* psContext, const Operand* psOperand);
+uint32_t GetNumSwizzleElementsMETAL(const Operand* psOperand);
+void AddSwizzleUsingElementCountMETAL(HLSLCrossCompilerContext* psContext, uint32_t count);
+int GetFirstOperandSwizzleMETAL(HLSLCrossCompilerContext* psContext, const Operand* psOperand);
+uint32_t IsSwizzleReplacatedMETAL(const Operand* psOperand);
+
+void TextureNameMETAL(HLSLCrossCompilerContext* psContext, const uint32_t ui32RegisterNumber, const int bZCompare);
+
+uint32_t ConvertOperandSwizzleToComponentMaskMETAL(const Operand* psOperand);
+//Non-zero means the components overlap
+int CompareOperandSwizzlesMETAL(const Operand* psOperandA, const Operand* psOperandB);
+
+SHADER_VARIABLE_TYPE GetOperandDataTypeMETAL(HLSLCrossCompilerContext* psContext, const Operand* psOperand);
+
+#endif
@@ -0,0 +1,812 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#ifndef TOKENS_H
+#define TOKENS_H
+
+#include "hlslcc.h"
+
+typedef enum
+{
+    INVALID_SHADER = -1,
+    PIXEL_SHADER,
+    VERTEX_SHADER,
+    GEOMETRY_SHADER,
+    HULL_SHADER,
+    DOMAIN_SHADER,
+    COMPUTE_SHADER,
+} SHADER_TYPE;
+
+static SHADER_TYPE DecodeShaderType(uint32_t ui32Token)
+{
+    return (SHADER_TYPE)((ui32Token & 0xffff0000) >> 16);
+}
+
+static uint32_t DecodeProgramMajorVersion(uint32_t ui32Token)
+{
+    return (ui32Token & 0x000000f0) >> 4;
+}
+
+static uint32_t DecodeProgramMinorVersion(uint32_t ui32Token)
+{
+    return (ui32Token & 0x0000000f);
+}
+
+static uint32_t DecodeInstructionLength(uint32_t ui32Token)
+{
+    return (ui32Token & 0x7f000000) >> 24;
+}
+
+static uint32_t DecodeIsOpcodeExtended(uint32_t ui32Token)
+{
+    return (ui32Token & 0x80000000) >> 31;
+}
+
+typedef enum EXTENDED_OPCODE_TYPE
+{
+    EXTENDED_OPCODE_EMPTY           = 0,
+    EXTENDED_OPCODE_SAMPLE_CONTROLS = 1,
+    EXTENDED_OPCODE_RESOURCE_DIM = 2,
+    EXTENDED_OPCODE_RESOURCE_RETURN_TYPE = 3,
+} EXTENDED_OPCODE_TYPE;
+
+static EXTENDED_OPCODE_TYPE DecodeExtendedOpcodeType(uint32_t ui32Token)
+{
+    return (EXTENDED_OPCODE_TYPE)(ui32Token & 0x0000003f);
+}
+
+typedef enum RESOURCE_RETURN_TYPE
+{
+    RETURN_TYPE_UNORM = 1,
+    RETURN_TYPE_SNORM = 2,
+    RETURN_TYPE_SINT = 3,
+    RETURN_TYPE_UINT = 4,
+    RETURN_TYPE_FLOAT = 5,
+    RETURN_TYPE_MIXED = 6,
+    RETURN_TYPE_DOUBLE = 7,
+    RETURN_TYPE_CONTINUED = 8,
+    RETURN_TYPE_UNUSED = 9,
+} RESOURCE_RETURN_TYPE;
+
+static RESOURCE_RETURN_TYPE DecodeResourceReturnType(uint32_t ui32Coord, uint32_t ui32Token)
+{
+    return (RESOURCE_RETURN_TYPE)((ui32Token>>(ui32Coord * 4))&0xF);
+}
+
+static RESOURCE_RETURN_TYPE DecodeExtendedResourceReturnType(uint32_t ui32Coord, uint32_t ui32Token)
+{
+    return (RESOURCE_RETURN_TYPE)((ui32Token>>(ui32Coord * 4 + 6))&0xF);
+}
+
+typedef enum
+{
+    //For DX9
+    OPCODE_POW = -6,
+    OPCODE_DP2ADD = -5,
+    OPCODE_LRP = -4,
+    OPCODE_ENDREP = -3,
+    OPCODE_REP = -2,
+    OPCODE_SPECIAL_DCL_IMMCONST = -1,
+
+    OPCODE_ADD,
+    OPCODE_AND,
+    OPCODE_BREAK,
+    OPCODE_BREAKC,
+    OPCODE_CALL,
+    OPCODE_CALLC,
+    OPCODE_CASE,
+    OPCODE_CONTINUE,
+    OPCODE_CONTINUEC,
+    OPCODE_CUT,
+    OPCODE_DEFAULT,
+    OPCODE_DERIV_RTX,
+    OPCODE_DERIV_RTY,
+    OPCODE_DISCARD,
+    OPCODE_DIV,
+    OPCODE_DP2,
+    OPCODE_DP3,
+    OPCODE_DP4,
+    OPCODE_ELSE,
+    OPCODE_EMIT,
+    OPCODE_EMITTHENCUT,
+    OPCODE_ENDIF,
+    OPCODE_ENDLOOP,
+    OPCODE_ENDSWITCH,
+    OPCODE_EQ,
+    OPCODE_EXP,
+    OPCODE_FRC,
+    OPCODE_FTOI,
+    OPCODE_FTOU,
+    OPCODE_GE,
+    OPCODE_IADD,
+    OPCODE_IF,
+    OPCODE_IEQ,
+    OPCODE_IGE,
+    OPCODE_ILT,
+    OPCODE_IMAD,
+    OPCODE_IMAX,
+    OPCODE_IMIN,
+    OPCODE_IMUL,
+    OPCODE_INE,
+    OPCODE_INEG,
+    OPCODE_ISHL,
+    OPCODE_ISHR,
+    OPCODE_ITOF,
+    OPCODE_LABEL,
+    OPCODE_LD,
+    OPCODE_LD_MS,
+    OPCODE_LOG,
+    OPCODE_LOOP,
+    OPCODE_LT,
+    OPCODE_MAD,
+    OPCODE_MIN,
+    OPCODE_MAX,
+    OPCODE_CUSTOMDATA,
+    OPCODE_MOV,
+    OPCODE_MOVC,
+    OPCODE_MUL,
+    OPCODE_NE,
+    OPCODE_NOP,
+    OPCODE_NOT,
+    OPCODE_OR,
+    OPCODE_RESINFO,
+    OPCODE_RET,
+    OPCODE_RETC,
+    OPCODE_ROUND_NE,
+    OPCODE_ROUND_NI,
+    OPCODE_ROUND_PI,
+    OPCODE_ROUND_Z,
+    OPCODE_RSQ,
+    OPCODE_SAMPLE,
+    OPCODE_SAMPLE_C,
+    OPCODE_SAMPLE_C_LZ,
+    OPCODE_SAMPLE_L,
+    OPCODE_SAMPLE_D,
+    OPCODE_SAMPLE_B,
+    OPCODE_SQRT,
+    OPCODE_SWITCH,
+    OPCODE_SINCOS,
+    OPCODE_UDIV,
+    OPCODE_ULT,
+    OPCODE_UGE,
+    OPCODE_UMUL,
+    OPCODE_UMAD,
+    OPCODE_UMAX,
+    OPCODE_UMIN,
+    OPCODE_USHR,
+    OPCODE_UTOF,
+    OPCODE_XOR,
+    OPCODE_DCL_RESOURCE, // DCL* opcodes have
+    OPCODE_DCL_CONSTANT_BUFFER, // custom operand formats.
+    OPCODE_DCL_SAMPLER,
+    OPCODE_DCL_INDEX_RANGE,
+    OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY,
+    OPCODE_DCL_GS_INPUT_PRIMITIVE,
+    OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT,
+    OPCODE_DCL_INPUT,
+    OPCODE_DCL_INPUT_SGV,
+    OPCODE_DCL_INPUT_SIV,
+    OPCODE_DCL_INPUT_PS,
+    OPCODE_DCL_INPUT_PS_SGV,
+    OPCODE_DCL_INPUT_PS_SIV,
+    OPCODE_DCL_OUTPUT,
+    OPCODE_DCL_OUTPUT_SGV,
+    OPCODE_DCL_OUTPUT_SIV,
+    OPCODE_DCL_TEMPS,
+    OPCODE_DCL_INDEXABLE_TEMP,
+    OPCODE_DCL_GLOBAL_FLAGS,
+
+    // -----------------------------------------------
+
+    OPCODE_RESERVED_10,
+
+    // ---------- DX 10.1 op codes---------------------
+
+    OPCODE_LOD,
+    OPCODE_GATHER4,
+    OPCODE_SAMPLE_POS,
+    OPCODE_SAMPLE_INFO,
+
+    // -----------------------------------------------
+
+    // This should be 10.1's version of NUM_OPCODES
+    OPCODE_RESERVED_10_1,
+
+    // ---------- DX 11 op codes---------------------
+    OPCODE_HS_DECLS, // token marks beginning of HS sub-shader
+    OPCODE_HS_CONTROL_POINT_PHASE, // token marks beginning of HS sub-shader
+    OPCODE_HS_FORK_PHASE, // token marks beginning of HS sub-shader
+    OPCODE_HS_JOIN_PHASE, // token marks beginning of HS sub-shader
+
+    OPCODE_EMIT_STREAM,
+    OPCODE_CUT_STREAM,
+    OPCODE_EMITTHENCUT_STREAM,
+    OPCODE_INTERFACE_CALL,
+
+    OPCODE_BUFINFO,
+    OPCODE_DERIV_RTX_COARSE,
+    OPCODE_DERIV_RTX_FINE,
+    OPCODE_DERIV_RTY_COARSE,
+    OPCODE_DERIV_RTY_FINE,
+    OPCODE_GATHER4_C,
+    OPCODE_GATHER4_PO,
+    OPCODE_GATHER4_PO_C,
+    OPCODE_RCP,
+    OPCODE_F32TOF16,
+    OPCODE_F16TOF32,
+    OPCODE_UADDC,
+    OPCODE_USUBB,
+    OPCODE_COUNTBITS,
+    OPCODE_FIRSTBIT_HI,
+    OPCODE_FIRSTBIT_LO,
+    OPCODE_FIRSTBIT_SHI,
+    OPCODE_UBFE,
+    OPCODE_IBFE,
+    OPCODE_BFI,
+    OPCODE_BFREV,
+    OPCODE_SWAPC,
+
+    OPCODE_DCL_STREAM,
+    OPCODE_DCL_FUNCTION_BODY,
+    OPCODE_DCL_FUNCTION_TABLE,
+    OPCODE_DCL_INTERFACE,
+
+    OPCODE_DCL_INPUT_CONTROL_POINT_COUNT,
+    OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT,
+    OPCODE_DCL_TESS_DOMAIN,
+    OPCODE_DCL_TESS_PARTITIONING,
+    OPCODE_DCL_TESS_OUTPUT_PRIMITIVE,
+    OPCODE_DCL_HS_MAX_TESSFACTOR,
+    OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT,
+    OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT,
+
+    OPCODE_DCL_THREAD_GROUP,
+    OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED,
+    OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW,
+    OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED,
+    OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW,
+    OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED,
+    OPCODE_DCL_RESOURCE_RAW,
+    OPCODE_DCL_RESOURCE_STRUCTURED,
+    OPCODE_LD_UAV_TYPED,
+    OPCODE_STORE_UAV_TYPED,
+    OPCODE_LD_RAW,
+    OPCODE_STORE_RAW,
+    OPCODE_LD_STRUCTURED,
+    OPCODE_STORE_STRUCTURED,
+    OPCODE_ATOMIC_AND,
+    OPCODE_ATOMIC_OR,
+    OPCODE_ATOMIC_XOR,
+    OPCODE_ATOMIC_CMP_STORE,
+    OPCODE_ATOMIC_IADD,
+    OPCODE_ATOMIC_IMAX,
+    OPCODE_ATOMIC_IMIN,
+    OPCODE_ATOMIC_UMAX,
+    OPCODE_ATOMIC_UMIN,
+    OPCODE_IMM_ATOMIC_ALLOC,
+    OPCODE_IMM_ATOMIC_CONSUME,
+    OPCODE_IMM_ATOMIC_IADD,
+    OPCODE_IMM_ATOMIC_AND,
+    OPCODE_IMM_ATOMIC_OR,
+    OPCODE_IMM_ATOMIC_XOR,
+    OPCODE_IMM_ATOMIC_EXCH,
+    OPCODE_IMM_ATOMIC_CMP_EXCH,
+    OPCODE_IMM_ATOMIC_IMAX,
+    OPCODE_IMM_ATOMIC_IMIN,
+    OPCODE_IMM_ATOMIC_UMAX,
+    OPCODE_IMM_ATOMIC_UMIN,   
+    OPCODE_SYNC,
+
+    OPCODE_DADD,
+    OPCODE_DMAX,
+    OPCODE_DMIN,
+    OPCODE_DMUL,
+    OPCODE_DEQ,
+    OPCODE_DGE,
+    OPCODE_DLT,
+    OPCODE_DNE,
+    OPCODE_DMOV,
+    OPCODE_DMOVC,
+    OPCODE_DTOF,
+    OPCODE_FTOD,
+
+    OPCODE_EVAL_SNAPPED,
+    OPCODE_EVAL_SAMPLE_INDEX,
+    OPCODE_EVAL_CENTROID,
+
+    OPCODE_DCL_GS_INSTANCE_COUNT,
+
+    OPCODE_ABORT,
+    OPCODE_DEBUG_BREAK,
+
+    // -----------------------------------------------
+
+    // This marks the end of D3D11.0 opcodes
+    OPCODE_RESERVED_11,
+
+    OPCODE_DDIV,
+    OPCODE_DFMA,
+    OPCODE_DRCP,
+
+    OPCODE_MSAD,
+
+    OPCODE_DTOI,
+    OPCODE_DTOU,
+    OPCODE_ITOD,
+    OPCODE_UTOD,
+
+    // -----------------------------------------------
+
+    // This marks the end of D3D11.1 opcodes
+    OPCODE_RESERVED_11_1,
+
+    NUM_OPCODES,
+    OPCODE_INVAILD = NUM_OPCODES,
+} OPCODE_TYPE;
+
+static OPCODE_TYPE DecodeOpcodeType(uint32_t ui32Token)
+{
+    return (OPCODE_TYPE)(ui32Token & 0x00007ff);
+}
+
+typedef enum
+{
+    INDEX_0D,
+    INDEX_1D,
+    INDEX_2D,
+    INDEX_3D,
+} OPERAND_INDEX_DIMENSION;
+
+static OPERAND_INDEX_DIMENSION DecodeOperandIndexDimension(uint32_t ui32Token)
+{
+    return (OPERAND_INDEX_DIMENSION)((ui32Token & 0x00300000) >> 20);
+}
+
+typedef enum OPERAND_TYPE
+{
+    OPERAND_TYPE_SPECIAL_LOOPCOUNTER = -10,
+    OPERAND_TYPE_SPECIAL_IMMCONSTINT = -9,
+    OPERAND_TYPE_SPECIAL_TEXCOORD = -8,
+    OPERAND_TYPE_SPECIAL_POSITION = -7,
+    OPERAND_TYPE_SPECIAL_FOG = -6,
+    OPERAND_TYPE_SPECIAL_POINTSIZE = -5,
+    OPERAND_TYPE_SPECIAL_OUTOFFSETCOLOUR = -4,
+    OPERAND_TYPE_SPECIAL_OUTBASECOLOUR = -3,
+    OPERAND_TYPE_SPECIAL_ADDRESS = -2,
+    OPERAND_TYPE_SPECIAL_IMMCONST = -1,
+    OPERAND_TYPE_TEMP           = 0,  // Temporary Register File
+    OPERAND_TYPE_INPUT          = 1,  // General Input Register File
+    OPERAND_TYPE_OUTPUT         = 2,  // General Output Register File
+    OPERAND_TYPE_INDEXABLE_TEMP = 3,  // Temporary Register File (indexable)
+    OPERAND_TYPE_IMMEDIATE32    = 4,  // 32bit/component immediate value(s)
+    // If for example, operand token bits
+    // [01:00]==OPERAND_4_COMPONENT,
+    // this means that the operand type:
+    // OPERAND_TYPE_IMMEDIATE32
+    // results in 4 additional 32bit
+    // DWORDS present for the operand.
+    OPERAND_TYPE_IMMEDIATE64    = 5,  // 64bit/comp.imm.val(s)HI:LO
+    OPERAND_TYPE_SAMPLER        = 6,  // Reference to sampler state
+    OPERAND_TYPE_RESOURCE       = 7,  // Reference to memory resource (e.g. texture)
+    OPERAND_TYPE_CONSTANT_BUFFER= 8,  // Reference to constant buffer
+    OPERAND_TYPE_IMMEDIATE_CONSTANT_BUFFER= 9,  // Reference to immediate constant buffer
+    OPERAND_TYPE_LABEL          = 10, // Label
+    OPERAND_TYPE_INPUT_PRIMITIVEID = 11, // Input primitive ID
+    OPERAND_TYPE_OUTPUT_DEPTH   = 12, // Output Depth
+    OPERAND_TYPE_NULL           = 13, // Null register, used to discard results of operations
+    // Below Are operands new in DX 10.1
+    OPERAND_TYPE_RASTERIZER     = 14, // DX10.1 Rasterizer register, used to denote the depth/stencil and render target resources
+    OPERAND_TYPE_OUTPUT_COVERAGE_MASK = 15, // DX10.1 PS output MSAA coverage mask (scalar)
+    // Below Are operands new in DX 11
+    OPERAND_TYPE_STREAM         = 16, // Reference to GS stream output resource
+    OPERAND_TYPE_FUNCTION_BODY  = 17, // Reference to a function definition
+    OPERAND_TYPE_FUNCTION_TABLE = 18, // Reference to a set of functions used by a class
+    OPERAND_TYPE_INTERFACE      = 19, // Reference to an interface
+    OPERAND_TYPE_FUNCTION_INPUT = 20, // Reference to an input parameter to a function
+    OPERAND_TYPE_FUNCTION_OUTPUT = 21, // Reference to an output parameter to a function
+    OPERAND_TYPE_OUTPUT_CONTROL_POINT_ID = 22, // HS Control Point phase input saying which output control point ID this is
+    OPERAND_TYPE_INPUT_FORK_INSTANCE_ID = 23, // HS Fork Phase input instance ID
+    OPERAND_TYPE_INPUT_JOIN_INSTANCE_ID = 24, // HS Join Phase input instance ID
+    OPERAND_TYPE_INPUT_CONTROL_POINT = 25, // HS Fork+Join, DS phase input control points (array of them)
+    OPERAND_TYPE_OUTPUT_CONTROL_POINT = 26, // HS Fork+Join phase output control points (array of them)
+    OPERAND_TYPE_INPUT_PATCH_CONSTANT = 27, // DS+HSJoin Input Patch Constants (array of them)
+    OPERAND_TYPE_INPUT_DOMAIN_POINT = 28, // DS Input Domain point
+    OPERAND_TYPE_THIS_POINTER       = 29, // Reference to an interface this pointer
+    OPERAND_TYPE_UNORDERED_ACCESS_VIEW = 30, // Reference to UAV u#
+    OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY = 31, // Reference to Thread Group Shared Memory g#
+    OPERAND_TYPE_INPUT_THREAD_ID = 32, // Compute Shader Thread ID
+    OPERAND_TYPE_INPUT_THREAD_GROUP_ID = 33, // Compute Shader Thread Group ID
+    OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP = 34, // Compute Shader Thread ID In Thread Group
+    OPERAND_TYPE_INPUT_COVERAGE_MASK = 35, // Pixel shader coverage mask input
+    OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED = 36, // Compute Shader Thread ID In Group Flattened to a 1D value.
+    OPERAND_TYPE_INPUT_GS_INSTANCE_ID = 37, // Input GS instance ID
+    OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL = 38, // Output Depth, forced to be greater than or equal than current depth
+    OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL    = 39, // Output Depth, forced to be less than or equal to current depth
+    OPERAND_TYPE_CYCLE_COUNTER = 40, // Cycle counter
+} OPERAND_TYPE;
+
+static OPERAND_TYPE DecodeOperandType(uint32_t ui32Token)
+{
+    return (OPERAND_TYPE)((ui32Token & 0x000ff000) >> 12);
+}
+
+static SPECIAL_NAME DecodeOperandSpecialName(uint32_t ui32Token)
+{
+    return (SPECIAL_NAME)(ui32Token & 0x0000ffff);
+}
+
+typedef enum OPERAND_INDEX_REPRESENTATION
+{
+    OPERAND_INDEX_IMMEDIATE32               = 0, // Extra DWORD
+    OPERAND_INDEX_IMMEDIATE64               = 1, // 2 Extra DWORDs
+    //   (HI32:LO32)
+    OPERAND_INDEX_RELATIVE                  = 2, // Extra operand
+    OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE = 3, // Extra DWORD followed by
+    //   extra operand
+    OPERAND_INDEX_IMMEDIATE64_PLUS_RELATIVE = 4, // 2 Extra DWORDS
+    //   (HI32:LO32) followed
+    //   by extra operand
+} OPERAND_INDEX_REPRESENTATION;
+
+static OPERAND_INDEX_REPRESENTATION DecodeOperandIndexRepresentation(uint32_t ui32Dimension, uint32_t ui32Token)
+{
+    return (OPERAND_INDEX_REPRESENTATION)((ui32Token & (0x3<<(22+3*((ui32Dimension)&3)))) >> (22+3*((ui32Dimension)&3)));
+}
+
+typedef enum OPERAND_NUM_COMPONENTS
+{
+    OPERAND_0_COMPONENT = 0,
+    OPERAND_1_COMPONENT = 1,
+    OPERAND_4_COMPONENT = 2,
+    OPERAND_N_COMPONENT = 3 // unused for now
+} OPERAND_NUM_COMPONENTS;
+
+static OPERAND_NUM_COMPONENTS DecodeOperandNumComponents(uint32_t ui32Token)
+{
+    return (OPERAND_NUM_COMPONENTS)(ui32Token & 0x00000003);
+}
+
+typedef enum OPERAND_4_COMPONENT_SELECTION_MODE
+{
+    OPERAND_4_COMPONENT_MASK_MODE    = 0,  // mask 4 components
+    OPERAND_4_COMPONENT_SWIZZLE_MODE = 1,  // swizzle 4 components
+    OPERAND_4_COMPONENT_SELECT_1_MODE = 2, // select 1 of 4 components
+} OPERAND_4_COMPONENT_SELECTION_MODE;
+
+static OPERAND_4_COMPONENT_SELECTION_MODE DecodeOperand4CompSelMode(uint32_t ui32Token)
+{
+    return (OPERAND_4_COMPONENT_SELECTION_MODE)((ui32Token & 0x0000000c) >> 2);
+}
+
+#define OPERAND_4_COMPONENT_MASK_X      0x00000001
+#define OPERAND_4_COMPONENT_MASK_Y      0x00000002
+#define OPERAND_4_COMPONENT_MASK_Z      0x00000004
+#define OPERAND_4_COMPONENT_MASK_W      0x00000008
+#define OPERAND_4_COMPONENT_MASK_R      OPERAND_4_COMPONENT_MASK_X
+#define OPERAND_4_COMPONENT_MASK_G      OPERAND_4_COMPONENT_MASK_Y
+#define OPERAND_4_COMPONENT_MASK_B      OPERAND_4_COMPONENT_MASK_Z
+#define OPERAND_4_COMPONENT_MASK_A      OPERAND_4_COMPONENT_MASK_W
+#define OPERAND_4_COMPONENT_MASK_ALL    0x0000000f
+
+static uint32_t DecodeOperand4CompMask(uint32_t ui32Token)
+{
+    return (uint32_t)((ui32Token & 0x000000f0) >> 4);
+}
+
+static uint32_t DecodeOperand4CompSwizzle(uint32_t ui32Token)
+{
+    return (uint32_t)((ui32Token & 0x00000ff0) >> 4);
+}
+
+static uint32_t DecodeOperand4CompSel1(uint32_t ui32Token)
+{
+    return (uint32_t)((ui32Token & 0x00000030) >> 4);
+}
+
+#define OPERAND_4_COMPONENT_X      0
+#define OPERAND_4_COMPONENT_Y      1
+#define OPERAND_4_COMPONENT_Z      2
+#define OPERAND_4_COMPONENT_W      3
+
+static uint32_t NO_SWIZZLE = (( (OPERAND_4_COMPONENT_X) | (OPERAND_4_COMPONENT_Y<<2) | (OPERAND_4_COMPONENT_Z << 4) | (OPERAND_4_COMPONENT_W << 6))/*<<4*/);
+
+static uint32_t XXXX_SWIZZLE = (((OPERAND_4_COMPONENT_X) | (OPERAND_4_COMPONENT_X<<2) | (OPERAND_4_COMPONENT_X << 4) | (OPERAND_4_COMPONENT_X << 6)));
+static uint32_t YYYY_SWIZZLE = (((OPERAND_4_COMPONENT_Y) | (OPERAND_4_COMPONENT_Y<<2) | (OPERAND_4_COMPONENT_Y << 4) | (OPERAND_4_COMPONENT_Y << 6)));
+static uint32_t ZZZZ_SWIZZLE = (((OPERAND_4_COMPONENT_Z) | (OPERAND_4_COMPONENT_Z<<2) | (OPERAND_4_COMPONENT_Z << 4) | (OPERAND_4_COMPONENT_Z << 6)));
+static uint32_t WWWW_SWIZZLE = (((OPERAND_4_COMPONENT_W) | (OPERAND_4_COMPONENT_W<<2) | (OPERAND_4_COMPONENT_W << 4) | (OPERAND_4_COMPONENT_W << 6)));
+
+static uint32_t DecodeOperand4CompSwizzleSource(uint32_t ui32Token, uint32_t comp)
+{
+    return (uint32_t)(((ui32Token)>>(4+2*((comp)&3)))&3);
+}
+
+typedef enum RESOURCE_DIMENSION
+{
+    RESOURCE_DIMENSION_UNKNOWN = 0,
+    RESOURCE_DIMENSION_BUFFER = 1,
+    RESOURCE_DIMENSION_TEXTURE1D = 2,
+    RESOURCE_DIMENSION_TEXTURE2D = 3,
+    RESOURCE_DIMENSION_TEXTURE2DMS = 4,
+    RESOURCE_DIMENSION_TEXTURE3D = 5,
+    RESOURCE_DIMENSION_TEXTURECUBE = 6,
+    RESOURCE_DIMENSION_TEXTURE1DARRAY = 7,
+    RESOURCE_DIMENSION_TEXTURE2DARRAY = 8,
+    RESOURCE_DIMENSION_TEXTURE2DMSARRAY = 9,
+    RESOURCE_DIMENSION_TEXTURECUBEARRAY = 10,
+    RESOURCE_DIMENSION_RAW_BUFFER = 11,
+    RESOURCE_DIMENSION_STRUCTURED_BUFFER = 12,
+} RESOURCE_DIMENSION;
+
+static RESOURCE_DIMENSION DecodeResourceDimension(uint32_t ui32Token)
+{
+    return (RESOURCE_DIMENSION)((ui32Token & 0x0000f800) >> 11);
+}
+
+static RESOURCE_DIMENSION DecodeExtendedResourceDimension(uint32_t ui32Token)
+{
+    return (RESOURCE_DIMENSION)((ui32Token & 0x000007C0) >> 6);
+}
+
+typedef enum CONSTANT_BUFFER_ACCESS_PATTERN
+{
+    CONSTANT_BUFFER_ACCESS_PATTERN_IMMEDIATEINDEXED = 0,
+    CONSTANT_BUFFER_ACCESS_PATTERN_DYNAMICINDEXED = 1
+} CONSTANT_BUFFER_ACCESS_PATTERN;
+
+static CONSTANT_BUFFER_ACCESS_PATTERN DecodeConstantBufferAccessPattern(uint32_t ui32Token)
+{
+    return (CONSTANT_BUFFER_ACCESS_PATTERN)((ui32Token & 0x00000800) >> 11);
+}
+
+typedef enum INSTRUCTION_TEST_BOOLEAN
+{
+    INSTRUCTION_TEST_ZERO       = 0,
+    INSTRUCTION_TEST_NONZERO    = 1
+} INSTRUCTION_TEST_BOOLEAN;
+
+static INSTRUCTION_TEST_BOOLEAN DecodeInstrTestBool(uint32_t ui32Token)
+{
+    return (INSTRUCTION_TEST_BOOLEAN)((ui32Token & 0x00040000) >> 18);
+}
+
+static uint32_t DecodeIsOperandExtended(uint32_t ui32Token)
+{
+    return (ui32Token & 0x80000000) >> 31;
+}
+
+typedef enum EXTENDED_OPERAND_TYPE
+{
+    EXTENDED_OPERAND_EMPTY            = 0,
+    EXTENDED_OPERAND_MODIFIER         = 1,
+} EXTENDED_OPERAND_TYPE;
+
+static EXTENDED_OPERAND_TYPE DecodeExtendedOperandType(uint32_t ui32Token)
+{
+    return (EXTENDED_OPERAND_TYPE)(ui32Token & 0x0000003f);
+}
+
+typedef enum OPERAND_MODIFIER
+{
+    OPERAND_MODIFIER_NONE     = 0,
+    OPERAND_MODIFIER_NEG      = 1,
+    OPERAND_MODIFIER_ABS      = 2,
+    OPERAND_MODIFIER_ABSNEG   = 3,
+} OPERAND_MODIFIER;
+
+static OPERAND_MODIFIER DecodeExtendedOperandModifier(uint32_t ui32Token)
+{
+    return (OPERAND_MODIFIER)((ui32Token & 0x00003fc0) >> 6);
+}
+
+static const uint32_t GLOBAL_FLAG_REFACTORING_ALLOWED = (1<<11);
+static const uint32_t GLOBAL_FLAG_ENABLE_DOUBLE_PRECISION_FLOAT_OPS = (1<<12);
+static const uint32_t GLOBAL_FLAG_FORCE_EARLY_DEPTH_STENCIL = (1<<13);
+static const uint32_t GLOBAL_FLAG_ENABLE_RAW_AND_STRUCTURED_BUFFERS = (1<<14);
+static const uint32_t GLOBAL_FLAG_SKIP_OPTIMIZATION = (1<<15);
+static const uint32_t GLOBAL_FLAG_ENABLE_MINIMUM_PRECISION = (1<<16);
+static const uint32_t GLOBAL_FLAG_ENABLE_DOUBLE_EXTENSIONS = (1<<17);
+static const uint32_t GLOBAL_FLAG_ENABLE_SHADER_EXTENSIONS = (1<<18);
+
+static uint32_t DecodeGlobalFlags(uint32_t ui32Token)
+{
+    return (uint32_t)(ui32Token & 0x00fff800);
+}
+
+static INTERPOLATION_MODE DecodeInterpolationMode(uint32_t ui32Token)
+{
+    return (INTERPOLATION_MODE)((ui32Token & 0x00007800) >> 11);
+}
+
+
+typedef enum PRIMITIVE_TOPOLOGY
+{
+    PRIMITIVE_TOPOLOGY_UNDEFINED = 0,
+    PRIMITIVE_TOPOLOGY_POINTLIST = 1,
+    PRIMITIVE_TOPOLOGY_LINELIST = 2,
+    PRIMITIVE_TOPOLOGY_LINESTRIP = 3,
+    PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4,
+    PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5,
+    // 6 is reserved for legacy triangle fans
+    // Adjacency values should be equal to (0x8 & non-adjacency):
+    PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10,
+    PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11,
+    PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12,
+    PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13,
+} PRIMITIVE_TOPOLOGY;
+
+static PRIMITIVE_TOPOLOGY DecodeGSOutputPrimitiveTopology(uint32_t ui32Token)
+{
+    return (PRIMITIVE_TOPOLOGY)((ui32Token & 0x0001f800) >> 11);
+}
+
+typedef enum PRIMITIVE
+{
+    PRIMITIVE_UNDEFINED = 0,
+    PRIMITIVE_POINT = 1,
+    PRIMITIVE_LINE = 2,
+    PRIMITIVE_TRIANGLE = 3,
+    // Adjacency values should be equal to (0x4 & non-adjacency):
+    PRIMITIVE_LINE_ADJ = 6,
+    PRIMITIVE_TRIANGLE_ADJ = 7,
+    PRIMITIVE_1_CONTROL_POINT_PATCH = 8,
+    PRIMITIVE_2_CONTROL_POINT_PATCH = 9,
+    PRIMITIVE_3_CONTROL_POINT_PATCH = 10,
+    PRIMITIVE_4_CONTROL_POINT_PATCH = 11,
+    PRIMITIVE_5_CONTROL_POINT_PATCH = 12,
+    PRIMITIVE_6_CONTROL_POINT_PATCH = 13,
+    PRIMITIVE_7_CONTROL_POINT_PATCH = 14,
+    PRIMITIVE_8_CONTROL_POINT_PATCH = 15,
+    PRIMITIVE_9_CONTROL_POINT_PATCH = 16,
+    PRIMITIVE_10_CONTROL_POINT_PATCH = 17,
+    PRIMITIVE_11_CONTROL_POINT_PATCH = 18,
+    PRIMITIVE_12_CONTROL_POINT_PATCH = 19,
+    PRIMITIVE_13_CONTROL_POINT_PATCH = 20,
+    PRIMITIVE_14_CONTROL_POINT_PATCH = 21,
+    PRIMITIVE_15_CONTROL_POINT_PATCH = 22,
+    PRIMITIVE_16_CONTROL_POINT_PATCH = 23,
+    PRIMITIVE_17_CONTROL_POINT_PATCH = 24,
+    PRIMITIVE_18_CONTROL_POINT_PATCH = 25,
+    PRIMITIVE_19_CONTROL_POINT_PATCH = 26,
+    PRIMITIVE_20_CONTROL_POINT_PATCH = 27,
+    PRIMITIVE_21_CONTROL_POINT_PATCH = 28,
+    PRIMITIVE_22_CONTROL_POINT_PATCH = 29,
+    PRIMITIVE_23_CONTROL_POINT_PATCH = 30,
+    PRIMITIVE_24_CONTROL_POINT_PATCH = 31,
+    PRIMITIVE_25_CONTROL_POINT_PATCH = 32,
+    PRIMITIVE_26_CONTROL_POINT_PATCH = 33,
+    PRIMITIVE_27_CONTROL_POINT_PATCH = 34,
+    PRIMITIVE_28_CONTROL_POINT_PATCH = 35,
+    PRIMITIVE_29_CONTROL_POINT_PATCH = 36,
+    PRIMITIVE_30_CONTROL_POINT_PATCH = 37,
+    PRIMITIVE_31_CONTROL_POINT_PATCH = 38,
+    PRIMITIVE_32_CONTROL_POINT_PATCH = 39,
+} PRIMITIVE;
+
+static PRIMITIVE DecodeGSInputPrimitive(uint32_t ui32Token)
+{
+    return (PRIMITIVE)((ui32Token & 0x0001f800) >> 11);
+}
+
+static TESSELLATOR_PARTITIONING DecodeTessPartitioning(uint32_t ui32Token)
+{
+    return (TESSELLATOR_PARTITIONING)((ui32Token & 0x00003800) >> 11);
+}
+
+typedef enum TESSELLATOR_DOMAIN
+{
+    TESSELLATOR_DOMAIN_UNDEFINED = 0,
+    TESSELLATOR_DOMAIN_ISOLINE   = 1,
+    TESSELLATOR_DOMAIN_TRI       = 2,
+    TESSELLATOR_DOMAIN_QUAD      = 3
+} TESSELLATOR_DOMAIN;
+
+static TESSELLATOR_DOMAIN DecodeTessDomain(uint32_t ui32Token)
+{
+    return (TESSELLATOR_DOMAIN)((ui32Token & 0x00001800) >> 11);
+}
+
+static TESSELLATOR_OUTPUT_PRIMITIVE DecodeTessOutPrim(uint32_t ui32Token)
+{
+    return (TESSELLATOR_OUTPUT_PRIMITIVE)((ui32Token & 0x00003800) >> 11);
+}
+
+static const uint32_t SYNC_THREADS_IN_GROUP = 0x00000800;
+static const uint32_t SYNC_THREAD_GROUP_SHARED_MEMORY = 0x00001000;
+static const uint32_t SYNC_UNORDERED_ACCESS_VIEW_MEMORY_GROUP = 0x00002000;
+static const uint32_t SYNC_UNORDERED_ACCESS_VIEW_MEMORY_GLOBAL = 0x00004000;
+
+static uint32_t DecodeSyncFlags(uint32_t ui32Token)
+{
+    return ui32Token & 0x00007800;
+}
+
+// The number of types that implement this interface
+static uint32_t DecodeInterfaceTableLength(uint32_t ui32Token)
+{
+    return (uint32_t)((ui32Token & 0x0000ffff) >> 0);
+}
+
+// The number of interfaces that are defined in this array.
+static uint32_t DecodeInterfaceArrayLength(uint32_t ui32Token)
+{
+    return (uint32_t)((ui32Token & 0xffff0000) >> 16);
+}
+
+typedef enum CUSTOMDATA_CLASS
+{
+    CUSTOMDATA_COMMENT = 0,
+    CUSTOMDATA_DEBUGINFO,
+    CUSTOMDATA_OPAQUE,
+    CUSTOMDATA_DCL_IMMEDIATE_CONSTANT_BUFFER,
+    CUSTOMDATA_SHADER_MESSAGE,
+} CUSTOMDATA_CLASS;
+
+static CUSTOMDATA_CLASS DecodeCustomDataClass(uint32_t ui32Token)
+{
+    return (CUSTOMDATA_CLASS)((ui32Token & 0xfffff800) >> 11);
+}
+
+static uint32_t DecodeInstructionSaturate(uint32_t ui32Token)
+{
+    return (ui32Token & 0x00002000) ? 1 : 0;
+}
+
+typedef enum OPERAND_MIN_PRECISION
+{
+    OPERAND_MIN_PRECISION_DEFAULT    = 0, // Default precision 
+    // for the shader model
+    OPERAND_MIN_PRECISION_FLOAT_16   = 1, // Min 16 bit/component float
+    OPERAND_MIN_PRECISION_FLOAT_2_8  = 2, // Min 10(2.8)bit/comp. float
+    OPERAND_MIN_PRECISION_SINT_16    = 4, // Min 16 bit/comp. signed integer
+    OPERAND_MIN_PRECISION_UINT_16    = 5, // Min 16 bit/comp. unsigned integer
+} OPERAND_MIN_PRECISION;
+
+static uint32_t DecodeOperandMinPrecision(uint32_t ui32Token)
+{
+    return (ui32Token & 0x0001C000) >> 14;
+}
+
+static uint32_t DecodeOutputControlPointCount(uint32_t ui32Token)
+{
+    return ((ui32Token & 0x0001f800) >> 11);
+}
+
+typedef enum IMMEDIATE_ADDRESS_OFFSET_COORD
+{
+    IMMEDIATE_ADDRESS_OFFSET_U        = 0,
+    IMMEDIATE_ADDRESS_OFFSET_V        = 1,
+    IMMEDIATE_ADDRESS_OFFSET_W        = 2,
+} IMMEDIATE_ADDRESS_OFFSET_COORD;
+
+
+#define IMMEDIATE_ADDRESS_OFFSET_SHIFT(Coord) (9+4*((Coord)&3))
+#define IMMEDIATE_ADDRESS_OFFSET_MASK(Coord) (0x0000000f<<IMMEDIATE_ADDRESS_OFFSET_SHIFT(Coord))
+
+static uint32_t DecodeImmediateAddressOffset(IMMEDIATE_ADDRESS_OFFSET_COORD eCoord, uint32_t ui32Token)
+{
+    return ((((ui32Token)&IMMEDIATE_ADDRESS_OFFSET_MASK(eCoord))>>(IMMEDIATE_ADDRESS_OFFSET_SHIFT(eCoord))));
+}
+
+// UAV access scope flags
+static const uint32_t GLOBALLY_COHERENT_ACCESS = 0x00010000;
+static uint32_t DecodeAccessCoherencyFlags(uint32_t ui32Token)
+{
+    return ui32Token & 0x00010000;
+}
+
+
+typedef enum RESINFO_RETURN_TYPE
+{
+    RESINFO_INSTRUCTION_RETURN_FLOAT      = 0,
+    RESINFO_INSTRUCTION_RETURN_RCPFLOAT   = 1,
+    RESINFO_INSTRUCTION_RETURN_UINT       = 2
+} RESINFO_RETURN_TYPE;
+
+static RESINFO_RETURN_TYPE DecodeResInfoReturnType(uint32_t ui32Token)
+{
+    return (RESINFO_RETURN_TYPE)((ui32Token & 0x00001800) >> 11);
+}
+
+#include "tokensDX9.h"
+
+#endif
@@ -0,0 +1,304 @@
+// Modifications copyright Amazon.com, Inc. or its affiliates
+// Modifications copyright Crytek GmbH
+
+#include "debug.h"
+
+static const uint32_t D3D9SHADER_TYPE_VERTEX = 0xFFFE0000;
+static const uint32_t D3D9SHADER_TYPE_PIXEL = 0xFFFF0000;
+
+static SHADER_TYPE DecodeShaderTypeDX9(const uint32_t ui32Token)
+{
+    uint32_t ui32Type = ui32Token & 0xFFFF0000;
+    if(ui32Type == D3D9SHADER_TYPE_VERTEX)
+        return VERTEX_SHADER;
+
+    if(ui32Type == D3D9SHADER_TYPE_PIXEL)
+        return PIXEL_SHADER;
+
+    return INVALID_SHADER;
+}
+
+static uint32_t DecodeProgramMajorVersionDX9(const uint32_t ui32Token)
+{
+    return ((ui32Token)>>8)&0xFF;
+}
+
+static uint32_t DecodeProgramMinorVersionDX9(const uint32_t ui32Token)
+{
+    return ui32Token & 0xFF;
+}
+
+typedef enum
+{
+    OPCODE_DX9_NOP          = 0,
+    OPCODE_DX9_MOV          ,
+    OPCODE_DX9_ADD          ,
+    OPCODE_DX9_SUB          ,
+    OPCODE_DX9_MAD          ,
+    OPCODE_DX9_MUL          ,
+    OPCODE_DX9_RCP          ,
+    OPCODE_DX9_RSQ          ,
+    OPCODE_DX9_DP3          ,
+    OPCODE_DX9_DP4          ,
+    OPCODE_DX9_MIN          ,
+    OPCODE_DX9_MAX          ,
+    OPCODE_DX9_SLT          ,
+    OPCODE_DX9_SGE          ,
+    OPCODE_DX9_EXP          ,
+    OPCODE_DX9_LOG          ,
+    OPCODE_DX9_LIT          ,
+    OPCODE_DX9_DST          ,
+    OPCODE_DX9_LRP          ,
+    OPCODE_DX9_FRC          ,
+    OPCODE_DX9_M4x4         ,
+    OPCODE_DX9_M4x3         ,
+    OPCODE_DX9_M3x4         ,
+    OPCODE_DX9_M3x3         ,
+    OPCODE_DX9_M3x2         ,
+    OPCODE_DX9_CALL         ,
+    OPCODE_DX9_CALLNZ       ,
+    OPCODE_DX9_LOOP         ,
+    OPCODE_DX9_RET          ,
+    OPCODE_DX9_ENDLOOP      ,
+    OPCODE_DX9_LABEL        ,
+    OPCODE_DX9_DCL          ,
+    OPCODE_DX9_POW          ,
+    OPCODE_DX9_CRS          ,
+    OPCODE_DX9_SGN          ,
+    OPCODE_DX9_ABS          ,
+    OPCODE_DX9_NRM          ,
+    OPCODE_DX9_SINCOS       ,
+    OPCODE_DX9_REP          ,
+    OPCODE_DX9_ENDREP       ,
+    OPCODE_DX9_IF           ,
+    OPCODE_DX9_IFC          ,
+    OPCODE_DX9_ELSE         ,
+    OPCODE_DX9_ENDIF        ,
+    OPCODE_DX9_BREAK        ,
+    OPCODE_DX9_BREAKC       ,
+    OPCODE_DX9_MOVA         ,
+    OPCODE_DX9_DEFB         ,
+    OPCODE_DX9_DEFI         ,
+
+    OPCODE_DX9_TEXCOORD     = 64,
+    OPCODE_DX9_TEXKILL      ,
+    OPCODE_DX9_TEX          ,
+    OPCODE_DX9_TEXBEM       ,
+    OPCODE_DX9_TEXBEML      ,
+    OPCODE_DX9_TEXREG2AR    ,
+    OPCODE_DX9_TEXREG2GB    ,
+    OPCODE_DX9_TEXM3x2PAD   ,
+    OPCODE_DX9_TEXM3x2TEX   ,
+    OPCODE_DX9_TEXM3x3PAD   ,
+    OPCODE_DX9_TEXM3x3TEX   ,
+    OPCODE_DX9_RESERVED0    ,
+    OPCODE_DX9_TEXM3x3SPEC  ,
+    OPCODE_DX9_TEXM3x3VSPEC ,
+    OPCODE_DX9_EXPP         ,
+    OPCODE_DX9_LOGP         ,
+    OPCODE_DX9_CND          ,
+    OPCODE_DX9_DEF          ,
+    OPCODE_DX9_TEXREG2RGB   ,
+    OPCODE_DX9_TEXDP3TEX    ,
+    OPCODE_DX9_TEXM3x2DEPTH ,
+    OPCODE_DX9_TEXDP3       ,
+    OPCODE_DX9_TEXM3x3      ,
+    OPCODE_DX9_TEXDEPTH     ,
+    OPCODE_DX9_CMP          ,
+    OPCODE_DX9_BEM          ,
+    OPCODE_DX9_DP2ADD       ,
+    OPCODE_DX9_DSX          ,
+    OPCODE_DX9_DSY          ,
+    OPCODE_DX9_TEXLDD       ,
+    OPCODE_DX9_SETP         ,
+    OPCODE_DX9_TEXLDL       ,
+    OPCODE_DX9_BREAKP       ,
+
+    OPCODE_DX9_PHASE        = 0xFFFD,
+    OPCODE_DX9_COMMENT      = 0xFFFE,
+    OPCODE_DX9_END          = 0xFFFF,
+
+    OPCODE_DX9_FORCE_DWORD  = 0x7fffffff,   // force 32-bit size enum
+} OPCODE_TYPE_DX9;
+
+static OPCODE_TYPE_DX9 DecodeOpcodeTypeDX9(const uint32_t ui32Token)
+{
+    return (OPCODE_TYPE_DX9)(ui32Token & 0x0000FFFF);
+}
+
+static uint32_t DecodeInstructionLengthDX9(const uint32_t ui32Token)
+{
+    return (ui32Token & 0x0F000000)>>24;
+}
+
+static uint32_t DecodeCommentLengthDX9(const uint32_t ui32Token)
+{
+    return (ui32Token & 0x7FFF0000)>>16;
+}
+
+static uint32_t DecodeOperandRegisterNumberDX9(const uint32_t ui32Token)
+{
+    return ui32Token & 0x000007FF;
+}
+
+typedef enum
+{
+    OPERAND_TYPE_DX9_TEMP           =  0, // Temporary Register File
+    OPERAND_TYPE_DX9_INPUT          =  1, // Input Register File
+    OPERAND_TYPE_DX9_CONST          =  2, // Constant Register File
+    OPERAND_TYPE_DX9_ADDR           =  3, // Address Register (VS)
+    OPERAND_TYPE_DX9_TEXTURE        =  3, // Texture Register File (PS)
+    OPERAND_TYPE_DX9_RASTOUT        =  4, // Rasterizer Register File
+    OPERAND_TYPE_DX9_ATTROUT        =  5, // Attribute Output Register File
+    OPERAND_TYPE_DX9_TEXCRDOUT      =  6, // Texture Coordinate Output Register File
+    OPERAND_TYPE_DX9_OUTPUT         =  6, // Output register file for VS3.0+
+    OPERAND_TYPE_DX9_CONSTINT       =  7, // Constant Integer Vector Register File
+    OPERAND_TYPE_DX9_COLOROUT       =  8, // Color Output Register File
+    OPERAND_TYPE_DX9_DEPTHOUT       =  9, // Depth Output Register File
+    OPERAND_TYPE_DX9_SAMPLER        = 10, // Sampler State Register File
+    OPERAND_TYPE_DX9_CONST2         = 11, // Constant Register File  2048 - 4095
+    OPERAND_TYPE_DX9_CONST3         = 12, // Constant Register File  4096 - 6143
+    OPERAND_TYPE_DX9_CONST4         = 13, // Constant Register File  6144 - 8191
+    OPERAND_TYPE_DX9_CONSTBOOL      = 14, // Constant Boolean register file
+    OPERAND_TYPE_DX9_LOOP           = 15, // Loop counter register file
+    OPERAND_TYPE_DX9_TEMPFLOAT16    = 16, // 16-bit float temp register file
+    OPERAND_TYPE_DX9_MISCTYPE       = 17, // Miscellaneous (single) registers.
+    OPERAND_TYPE_DX9_LABEL          = 18, // Label
+    OPERAND_TYPE_DX9_PREDICATE      = 19, // Predicate register
+    OPERAND_TYPE_DX9_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
+} OPERAND_TYPE_DX9;
+
+static OPERAND_TYPE_DX9 DecodeOperandTypeDX9(const uint32_t ui32Token)
+{
+    return (OPERAND_TYPE_DX9)(((ui32Token & 0x70000000) >> 28) |
+        ((ui32Token & 0x00001800) >> 8));
+}
+
+static uint32_t CreateOperandTokenDX9(const uint32_t ui32RegNum, const OPERAND_TYPE_DX9 eType)
+{
+    uint32_t ui32Token = ui32RegNum;
+    ASSERT(ui32RegNum <2048);
+    ui32Token |= (eType <<28) & 0x70000000;
+    ui32Token |= (eType <<8) & 0x00001800;
+    return ui32Token;
+}
+
+typedef enum { 
+    DECLUSAGE_POSITION      = 0,
+    DECLUSAGE_BLENDWEIGHT   = 1,
+    DECLUSAGE_BLENDINDICES  = 2,
+    DECLUSAGE_NORMAL        = 3,
+    DECLUSAGE_PSIZE         = 4,
+    DECLUSAGE_TEXCOORD      = 5,
+    DECLUSAGE_TANGENT       = 6,
+    DECLUSAGE_BINORMAL      = 7,
+    DECLUSAGE_TESSFACTOR    = 8,
+    DECLUSAGE_POSITIONT     = 9,
+    DECLUSAGE_COLOR         = 10,
+    DECLUSAGE_FOG           = 11,
+    DECLUSAGE_DEPTH         = 12,
+    DECLUSAGE_SAMPLE        = 13
+} DECLUSAGE_DX9;
+
+static DECLUSAGE_DX9 DecodeUsageDX9(const uint32_t ui32Token)
+{
+    return (DECLUSAGE_DX9) (ui32Token & 0x0000000f);
+}
+
+static uint32_t DecodeUsageIndexDX9(const uint32_t ui32Token)
+{
+    return (ui32Token & 0x000f0000)>>16;
+}
+
+static uint32_t DecodeOperandIsRelativeAddressModeDX9(const uint32_t ui32Token)
+{
+    return ui32Token & (1<<13);
+}
+
+static const uint32_t DX9_SWIZZLE_SHIFT = 16;
+#define NO_SWIZZLE_DX9 ((0<<DX9_SWIZZLE_SHIFT)|(1<<DX9_SWIZZLE_SHIFT)|(2<<DX9_SWIZZLE_SHIFT)|(3<<DX9_SWIZZLE_SHIFT))
+
+#define REPLICATE_SWIZZLE_DX9(CHANNEL) ((CHANNEL<<DX9_SWIZZLE_SHIFT)|(CHANNEL<<(DX9_SWIZZLE_SHIFT+2))|(CHANNEL<<(DX9_SWIZZLE_SHIFT+4))|(CHANNEL<<(DX9_SWIZZLE_SHIFT+6)))
+
+static uint32_t DecodeOperandSwizzleDX9(const uint32_t ui32Token)
+{
+    return ui32Token & 0x00FF0000;
+}
+
+static const uint32_t DX9_WRITEMASK_0 = 0x00010000;  // Component 0 (X;Red)
+static const uint32_t DX9_WRITEMASK_1 = 0x00020000;  // Component 1 (Y;Green)
+static const uint32_t DX9_WRITEMASK_2 = 0x00040000;  // Component 2 (Z;Blue)
+static const uint32_t DX9_WRITEMASK_3 = 0x00080000;  // Component 3 (W;Alpha)
+static const uint32_t DX9_WRITEMASK_ALL = 0x000F0000;  // All Components
+
+static uint32_t DecodeDestWriteMaskDX9(const uint32_t ui32Token)
+{
+    return ui32Token & DX9_WRITEMASK_ALL;
+}
+
+static RESOURCE_DIMENSION DecodeTextureTypeMaskDX9(const uint32_t ui32Token)
+{
+
+    switch(ui32Token & 0x78000000)
+    {
+    case 2 << 27:
+        return RESOURCE_DIMENSION_TEXTURE2D;
+    case 3 << 27:
+        return RESOURCE_DIMENSION_TEXTURECUBE;
+    case 4 << 27:
+        return RESOURCE_DIMENSION_TEXTURE3D;
+    default:
+        return RESOURCE_DIMENSION_UNKNOWN;
+    }
+}
+
+
+
+static const uint32_t DESTMOD_DX9_NONE    = 0;
+static const uint32_t DESTMOD_DX9_SATURATE    = (1 << 20);
+static const uint32_t DESTMOD_DX9_PARTIALPRECISION    = (2 << 20);
+static const uint32_t DESTMOD_DX9_MSAMPCENTROID = (4 << 20);
+static uint32_t DecodeDestModifierDX9(const uint32_t ui32Token)
+{
+    return ui32Token & 0xf00000;
+}
+
+typedef enum
+{
+    SRCMOD_DX9_NONE = 0 << 24,
+    SRCMOD_DX9_NEG = 1 << 24,
+    SRCMOD_DX9_BIAS = 2 << 24,
+    SRCMOD_DX9_BIASNEG = 3 << 24,
+    SRCMOD_DX9_SIGN = 4 << 24,
+    SRCMOD_DX9_SIGNNEG = 5 << 24,
+    SRCMOD_DX9_COMP = 6 << 24,
+    SRCMOD_DX9_X2 = 7 << 24,
+    SRCMOD_DX9_X2NEG = 8 << 24,
+    SRCMOD_DX9_DZ = 9 << 24,
+    SRCMOD_DX9_DW = 10 << 24,
+    SRCMOD_DX9_ABS = 11 << 24,
+    SRCMOD_DX9_ABSNEG = 12 << 24,
+    SRCMOD_DX9_NOT = 13 << 24,
+    SRCMOD_DX9_FORCE_DWORD = 0xffffffff
+} SRCMOD_DX9;
+static uint32_t DecodeSrcModifierDX9(const uint32_t ui32Token)
+{
+    return ui32Token & 0xf000000;
+}
+
+typedef enum
+{
+    D3DSPC_RESERVED0 = 0,
+    D3DSPC_GT = 1,
+    D3DSPC_EQ = 2,
+    D3DSPC_GE = 3,
+    D3DSPC_LT = 4,
+    D3DSPC_NE = 5,
+    D3DSPC_LE = 6,
+    D3DSPC_BOOLEAN = 7, //Make use of the RESERVED1 bit to indicate if-bool opcode.
+} COMPARISON_DX9;
+
+static COMPARISON_DX9 DecodeComparisonDX9(const uint32_t ui32Token)
+{
+    return (COMPARISON_DX9)((ui32Token & (0x07<<16))>>16);
+}