git.oblomov.eu Git - wine/blob - dlls/wined3d/shader_sm1.c

   1 /*
   2  * Copyright 2002-2003 Jason Edmeades
   3  * Copyright 2002-2003 Raphael Junqueira
   4  * Copyright 2004 Christian Costa
   5  * Copyright 2005 Oliver Stieber
   6  * Copyright 2006 Ivan Gyurdiev
   7  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
   8  * Copyright 2009 Henri Verbeet for CodeWeavers
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include "wined3d_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  31
  32 /* DCL usage masks */
  33 #define WINED3DSP_DCL_USAGE_SHIFT               0
  34 #define WINED3DSP_DCL_USAGE_MASK                (0xf << WINED3DSP_DCL_USAGE_SHIFT)
  35 #define WINED3DSP_DCL_USAGEINDEX_SHIFT          16
  36 #define WINED3DSP_DCL_USAGEINDEX_MASK           (0xf << WINED3DSP_DCL_USAGEINDEX_SHIFT)
  37
  38 /* DCL sampler type */
  39 #define WINED3DSP_TEXTURETYPE_SHIFT             27
  40 #define WINED3DSP_TEXTURETYPE_MASK              (0xf << WINED3DSP_TEXTURETYPE_SHIFT)
  41
  42 /* Opcode-related masks */
  43 #define WINED3DSI_OPCODE_MASK                   0x0000ffff
  44
  45 #define WINED3D_OPCODESPECIFICCONTROL_SHIFT     16
  46 #define WINED3D_OPCODESPECIFICCONTROL_MASK      (0xff << WINED3D_OPCODESPECIFICCONTROL_SHIFT)
  47
  48 #define WINED3DSI_INSTLENGTH_SHIFT              24
  49 #define WINED3DSI_INSTLENGTH_MASK               (0xf << WINED3DSI_INSTLENGTH_SHIFT)
  50
  51 #define WINED3DSI_COISSUE                       (1 << 30)
  52
  53 #define WINED3DSI_COMMENTSIZE_SHIFT             16
  54 #define WINED3DSI_COMMENTSIZE_MASK              (0x7fff << WINED3DSI_COMMENTSIZE_SHIFT)
  55
  56 #define WINED3DSHADER_INSTRUCTION_PREDICATED    (1 << 28)
  57
  58 /* Register number mask */
  59 #define WINED3DSP_REGNUM_MASK                   0x000007ff
  60
  61 /* Register type masks  */
  62 #define WINED3DSP_REGTYPE_SHIFT                 28
  63 #define WINED3DSP_REGTYPE_MASK                  (0x7 << WINED3DSP_REGTYPE_SHIFT)
  64 #define WINED3DSP_REGTYPE_SHIFT2                8
  65 #define WINED3DSP_REGTYPE_MASK2                 (0x18 << WINED3DSP_REGTYPE_SHIFT2)
  66
  67 /* Relative addressing mask */
  68 #define WINED3DSHADER_ADDRESSMODE_SHIFT         13
  69 #define WINED3DSHADER_ADDRESSMODE_MASK          (1 << WINED3DSHADER_ADDRESSMODE_SHIFT)
  70
  71 /* Destination modifier mask */
  72 #define WINED3DSP_DSTMOD_SHIFT                  20
  73 #define WINED3DSP_DSTMOD_MASK                   (0xf << WINED3DSP_DSTMOD_SHIFT)
  74
  75 /* Destination shift mask */
  76 #define WINED3DSP_DSTSHIFT_SHIFT                24
  77 #define WINED3DSP_DSTSHIFT_MASK                 (0xf << WINED3DSP_DSTSHIFT_SHIFT)
  78
  79 /* Write mask */
  80 #define WINED3D_SM1_WRITEMASK_SHIFT             16
  81 #define WINED3D_SM1_WRITEMASK_MASK              (0xf << WINED3D_SM1_WRITEMASK_SHIFT)
  82
  83 /* Swizzle mask */
  84 #define WINED3DSP_SWIZZLE_SHIFT                 16
  85 #define WINED3DSP_SWIZZLE_MASK                  (0xff << WINED3DSP_SWIZZLE_SHIFT)
  86
  87 /* Source modifier mask */
  88 #define WINED3DSP_SRCMOD_SHIFT                  24
  89 #define WINED3DSP_SRCMOD_MASK                   (0xf << WINED3DSP_SRCMOD_SHIFT)
  90
  91 #define WINED3DSP_END                           0x0000ffff
  92
  93 #define WINED3D_SM1_VERSION_MAJOR(version)      (((version) >> 8) & 0xff)
  94 #define WINED3D_SM1_VERSION_MINOR(version)      (((version) >> 0) & 0xff)
  95
  96 enum WINED3DSHADER_ADDRESSMODE_TYPE
  97 {
  98     WINED3DSHADER_ADDRMODE_ABSOLUTE = 0 << WINED3DSHADER_ADDRESSMODE_SHIFT,
  99     WINED3DSHADER_ADDRMODE_RELATIVE = 1 << WINED3DSHADER_ADDRESSMODE_SHIFT,
 100 };
 101
 102 enum wined3d_sm1_opcode
 103 {
 104     WINED3D_SM1_OP_NOP          = 0x00,
 105     WINED3D_SM1_OP_MOV          = 0x01,
 106     WINED3D_SM1_OP_ADD          = 0x02,
 107     WINED3D_SM1_OP_SUB          = 0x03,
 108     WINED3D_SM1_OP_MAD          = 0x04,
 109     WINED3D_SM1_OP_MUL          = 0x05,
 110     WINED3D_SM1_OP_RCP          = 0x06,
 111     WINED3D_SM1_OP_RSQ          = 0x07,
 112     WINED3D_SM1_OP_DP3          = 0x08,
 113     WINED3D_SM1_OP_DP4          = 0x09,
 114     WINED3D_SM1_OP_MIN          = 0x0a,
 115     WINED3D_SM1_OP_MAX          = 0x0b,
 116     WINED3D_SM1_OP_SLT          = 0x0c,
 117     WINED3D_SM1_OP_SGE          = 0x0d,
 118     WINED3D_SM1_OP_EXP          = 0x0e,
 119     WINED3D_SM1_OP_LOG          = 0x0f,
 120     WINED3D_SM1_OP_LIT          = 0x10,
 121     WINED3D_SM1_OP_DST          = 0x11,
 122     WINED3D_SM1_OP_LRP          = 0x12,
 123     WINED3D_SM1_OP_FRC          = 0x13,
 124     WINED3D_SM1_OP_M4x4         = 0x14,
 125     WINED3D_SM1_OP_M4x3         = 0x15,
 126     WINED3D_SM1_OP_M3x4         = 0x16,
 127     WINED3D_SM1_OP_M3x3         = 0x17,
 128     WINED3D_SM1_OP_M3x2         = 0x18,
 129     WINED3D_SM1_OP_CALL         = 0x19,
 130     WINED3D_SM1_OP_CALLNZ       = 0x1a,
 131     WINED3D_SM1_OP_LOOP         = 0x1b,
 132     WINED3D_SM1_OP_RET          = 0x1c,
 133     WINED3D_SM1_OP_ENDLOOP      = 0x1d,
 134     WINED3D_SM1_OP_LABEL        = 0x1e,
 135     WINED3D_SM1_OP_DCL          = 0x1f,
 136     WINED3D_SM1_OP_POW          = 0x20,
 137     WINED3D_SM1_OP_CRS          = 0x21,
 138     WINED3D_SM1_OP_SGN          = 0x22,
 139     WINED3D_SM1_OP_ABS          = 0x23,
 140     WINED3D_SM1_OP_NRM          = 0x24,
 141     WINED3D_SM1_OP_SINCOS       = 0x25,
 142     WINED3D_SM1_OP_REP          = 0x26,
 143     WINED3D_SM1_OP_ENDREP       = 0x27,
 144     WINED3D_SM1_OP_IF           = 0x28,
 145     WINED3D_SM1_OP_IFC          = 0x29,
 146     WINED3D_SM1_OP_ELSE         = 0x2a,
 147     WINED3D_SM1_OP_ENDIF        = 0x2b,
 148     WINED3D_SM1_OP_BREAK        = 0x2c,
 149     WINED3D_SM1_OP_BREAKC       = 0x2d,
 150     WINED3D_SM1_OP_MOVA         = 0x2e,
 151     WINED3D_SM1_OP_DEFB         = 0x2f,
 152     WINED3D_SM1_OP_DEFI         = 0x30,
 153
 154     WINED3D_SM1_OP_TEXCOORD     = 0x40,
 155     WINED3D_SM1_OP_TEXKILL      = 0x41,
 156     WINED3D_SM1_OP_TEX          = 0x42,
 157     WINED3D_SM1_OP_TEXBEM       = 0x43,
 158     WINED3D_SM1_OP_TEXBEML      = 0x44,
 159     WINED3D_SM1_OP_TEXREG2AR    = 0x45,
 160     WINED3D_SM1_OP_TEXREG2GB    = 0x46,
 161     WINED3D_SM1_OP_TEXM3x2PAD   = 0x47,
 162     WINED3D_SM1_OP_TEXM3x2TEX   = 0x48,
 163     WINED3D_SM1_OP_TEXM3x3PAD   = 0x49,
 164     WINED3D_SM1_OP_TEXM3x3TEX   = 0x4a,
 165     WINED3D_SM1_OP_TEXM3x3DIFF  = 0x4b,
 166     WINED3D_SM1_OP_TEXM3x3SPEC  = 0x4c,
 167     WINED3D_SM1_OP_TEXM3x3VSPEC = 0x4d,
 168     WINED3D_SM1_OP_EXPP         = 0x4e,
 169     WINED3D_SM1_OP_LOGP         = 0x4f,
 170     WINED3D_SM1_OP_CND          = 0x50,
 171     WINED3D_SM1_OP_DEF          = 0x51,
 172     WINED3D_SM1_OP_TEXREG2RGB   = 0x52,
 173     WINED3D_SM1_OP_TEXDP3TEX    = 0x53,
 174     WINED3D_SM1_OP_TEXM3x2DEPTH = 0x54,
 175     WINED3D_SM1_OP_TEXDP3       = 0x55,
 176     WINED3D_SM1_OP_TEXM3x3      = 0x56,
 177     WINED3D_SM1_OP_TEXDEPTH     = 0x57,
 178     WINED3D_SM1_OP_CMP          = 0x58,
 179     WINED3D_SM1_OP_BEM          = 0x59,
 180     WINED3D_SM1_OP_DP2ADD       = 0x5a,
 181     WINED3D_SM1_OP_DSX          = 0x5b,
 182     WINED3D_SM1_OP_DSY          = 0x5c,
 183     WINED3D_SM1_OP_TEXLDD       = 0x5d,
 184     WINED3D_SM1_OP_SETP         = 0x5e,
 185     WINED3D_SM1_OP_TEXLDL       = 0x5f,
 186     WINED3D_SM1_OP_BREAKP       = 0x60,
 187
 188     WINED3D_SM1_OP_PHASE        = 0xfffd,
 189     WINED3D_SM1_OP_COMMENT      = 0xfffe,
 190     WINED3D_SM1_OP_END          = 0Xffff,
 191 };
 192
 193 struct wined3d_sm1_opcode_info
 194 {
 195     enum wined3d_sm1_opcode opcode;
 196     UINT dst_count;
 197     UINT param_count;
 198     enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
 199     DWORD min_version;
 200     DWORD max_version;
 201 };
 202
 203 struct wined3d_sm1_data
 204 {
 205     struct wined3d_shader_version shader_version;
 206     const struct wined3d_sm1_opcode_info *opcode_table;
 207
 208     struct wined3d_shader_src_param src_rel_addr[4];
 209     struct wined3d_shader_src_param pred_rel_addr;
 210     struct wined3d_shader_src_param dst_rel_addr;
 211     struct wined3d_shader_src_param src_param[4];
 212     struct wined3d_shader_src_param pred_param;
 213     struct wined3d_shader_dst_param dst_param;
 214 };
 215
 216 /* This table is not order or position dependent. */
 217 static const struct wined3d_sm1_opcode_info vs_opcode_table[] =
 218 {
 219     /* Arithmetic */
 220     {WINED3D_SM1_OP_NOP,      0, 0, WINED3DSIH_NOP,          0,                           0                          },
 221     {WINED3D_SM1_OP_MOV,      1, 2, WINED3DSIH_MOV,          0,                           0                          },
 222     {WINED3D_SM1_OP_MOVA,     1, 2, WINED3DSIH_MOVA,         WINED3D_SHADER_VERSION(2,0), -1                         },
 223     {WINED3D_SM1_OP_ADD,      1, 3, WINED3DSIH_ADD,          0,                           0                          },
 224     {WINED3D_SM1_OP_SUB,      1, 3, WINED3DSIH_SUB,          0,                           0                          },
 225     {WINED3D_SM1_OP_MAD,      1, 4, WINED3DSIH_MAD,          0,                           0                          },
 226     {WINED3D_SM1_OP_MUL,      1, 3, WINED3DSIH_MUL,          0,                           0                          },
 227     {WINED3D_SM1_OP_RCP,      1, 2, WINED3DSIH_RCP,          0,                           0                          },
 228     {WINED3D_SM1_OP_RSQ,      1, 2, WINED3DSIH_RSQ,          0,                           0                          },
 229     {WINED3D_SM1_OP_DP3,      1, 3, WINED3DSIH_DP3,          0,                           0                          },
 230     {WINED3D_SM1_OP_DP4,      1, 3, WINED3DSIH_DP4,          0,                           0                          },
 231     {WINED3D_SM1_OP_MIN,      1, 3, WINED3DSIH_MIN,          0,                           0                          },
 232     {WINED3D_SM1_OP_MAX,      1, 3, WINED3DSIH_MAX,          0,                           0                          },
 233     {WINED3D_SM1_OP_SLT,      1, 3, WINED3DSIH_SLT,          0,                           0                          },
 234     {WINED3D_SM1_OP_SGE,      1, 3, WINED3DSIH_SGE,          0,                           0                          },
 235     {WINED3D_SM1_OP_ABS,      1, 2, WINED3DSIH_ABS,          0,                           0                          },
 236     {WINED3D_SM1_OP_EXP,      1, 2, WINED3DSIH_EXP,          0,                           0                          },
 237     {WINED3D_SM1_OP_LOG,      1, 2, WINED3DSIH_LOG,          0,                           0                          },
 238     {WINED3D_SM1_OP_EXPP,     1, 2, WINED3DSIH_EXPP,         0,                           0                          },
 239     {WINED3D_SM1_OP_LOGP,     1, 2, WINED3DSIH_LOGP,         0,                           0                          },
 240     {WINED3D_SM1_OP_LIT,      1, 2, WINED3DSIH_LIT,          0,                           0                          },
 241     {WINED3D_SM1_OP_DST,      1, 3, WINED3DSIH_DST,          0,                           0                          },
 242     {WINED3D_SM1_OP_LRP,      1, 4, WINED3DSIH_LRP,          0,                           0                          },
 243     {WINED3D_SM1_OP_FRC,      1, 2, WINED3DSIH_FRC,          0,                           0                          },
 244     {WINED3D_SM1_OP_POW,      1, 3, WINED3DSIH_POW,          0,                           0                          },
 245     {WINED3D_SM1_OP_CRS,      1, 3, WINED3DSIH_CRS,          0,                           0                          },
 246     {WINED3D_SM1_OP_SGN,      1, 4, WINED3DSIH_SGN,          WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
 247     {WINED3D_SM1_OP_SGN,      1, 2, WINED3DSIH_SGN,          WINED3D_SHADER_VERSION(3,0), -1                         },
 248     {WINED3D_SM1_OP_NRM,      1, 2, WINED3DSIH_NRM,          0,                           0                          },
 249     {WINED3D_SM1_OP_SINCOS,   1, 4, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
 250     {WINED3D_SM1_OP_SINCOS,   1, 2, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(3,0), -1                         },
 251     /* Matrix */
 252     {WINED3D_SM1_OP_M4x4,     1, 3, WINED3DSIH_M4x4,         0,                           0                          },
 253     {WINED3D_SM1_OP_M4x3,     1, 3, WINED3DSIH_M4x3,         0,                           0                          },
 254     {WINED3D_SM1_OP_M3x4,     1, 3, WINED3DSIH_M3x4,         0,                           0                          },
 255     {WINED3D_SM1_OP_M3x3,     1, 3, WINED3DSIH_M3x3,         0,                           0                          },
 256     {WINED3D_SM1_OP_M3x2,     1, 3, WINED3DSIH_M3x2,         0,                           0                          },
 257     /* Declare registers */
 258     {WINED3D_SM1_OP_DCL,      0, 2, WINED3DSIH_DCL,          0,                           0                          },
 259     /* Constant definitions */
 260     {WINED3D_SM1_OP_DEF,      1, 5, WINED3DSIH_DEF,          0,                           0                          },
 261     {WINED3D_SM1_OP_DEFB,     1, 2, WINED3DSIH_DEFB,         0,                           0                          },
 262     {WINED3D_SM1_OP_DEFI,     1, 5, WINED3DSIH_DEFI,         0,                           0                          },
 263     /* Flow control */
 264     {WINED3D_SM1_OP_REP,      0, 1, WINED3DSIH_REP,          WINED3D_SHADER_VERSION(2,0), -1                         },
 265     {WINED3D_SM1_OP_ENDREP,   0, 0, WINED3DSIH_ENDREP,       WINED3D_SHADER_VERSION(2,0), -1                         },
 266     {WINED3D_SM1_OP_IF,       0, 1, WINED3DSIH_IF,           WINED3D_SHADER_VERSION(2,0), -1                         },
 267     {WINED3D_SM1_OP_IFC,      0, 2, WINED3DSIH_IFC,          WINED3D_SHADER_VERSION(2,1), -1                         },
 268     {WINED3D_SM1_OP_ELSE,     0, 0, WINED3DSIH_ELSE,         WINED3D_SHADER_VERSION(2,0), -1                         },
 269     {WINED3D_SM1_OP_ENDIF,    0, 0, WINED3DSIH_ENDIF,        WINED3D_SHADER_VERSION(2,0), -1                         },
 270     {WINED3D_SM1_OP_BREAK,    0, 0, WINED3DSIH_BREAK,        WINED3D_SHADER_VERSION(2,1), -1                         },
 271     {WINED3D_SM1_OP_BREAKC,   0, 2, WINED3DSIH_BREAKC,       WINED3D_SHADER_VERSION(2,1), -1                         },
 272     {WINED3D_SM1_OP_BREAKP,   0, 1, WINED3DSIH_BREAKP,       0,                           0                          },
 273     {WINED3D_SM1_OP_CALL,     0, 1, WINED3DSIH_CALL,         WINED3D_SHADER_VERSION(2,0), -1                         },
 274     {WINED3D_SM1_OP_CALLNZ,   0, 2, WINED3DSIH_CALLNZ,       WINED3D_SHADER_VERSION(2,0), -1                         },
 275     {WINED3D_SM1_OP_LOOP,     0, 2, WINED3DSIH_LOOP,         WINED3D_SHADER_VERSION(2,0), -1                         },
 276     {WINED3D_SM1_OP_RET,      0, 0, WINED3DSIH_RET,          WINED3D_SHADER_VERSION(2,0), -1                         },
 277     {WINED3D_SM1_OP_ENDLOOP,  0, 0, WINED3DSIH_ENDLOOP,      WINED3D_SHADER_VERSION(2,0), -1                         },
 278     {WINED3D_SM1_OP_LABEL,    0, 1, WINED3DSIH_LABEL,        WINED3D_SHADER_VERSION(2,0), -1                         },
 279
 280     {WINED3D_SM1_OP_SETP,     1, 3, WINED3DSIH_SETP,         0,                           0                          },
 281     {WINED3D_SM1_OP_TEXLDL,   1, 3, WINED3DSIH_TEXLDL,       WINED3D_SHADER_VERSION(3,0), -1                         },
 282     {0,                       0, 0, WINED3DSIH_TABLE_SIZE,   0,                           0                          },
 283 };
 284
 285 static const struct wined3d_sm1_opcode_info ps_opcode_table[] =
 286 {
 287     /* Arithmetic */
 288     {WINED3D_SM1_OP_NOP,      0, 0, WINED3DSIH_NOP,          0,                           0                          },
 289     {WINED3D_SM1_OP_MOV,      1, 2, WINED3DSIH_MOV,          0,                           0                          },
 290     {WINED3D_SM1_OP_ADD,      1, 3, WINED3DSIH_ADD,          0,                           0                          },
 291     {WINED3D_SM1_OP_SUB,      1, 3, WINED3DSIH_SUB,          0,                           0                          },
 292     {WINED3D_SM1_OP_MAD,      1, 4, WINED3DSIH_MAD,          0,                           0                          },
 293     {WINED3D_SM1_OP_MUL,      1, 3, WINED3DSIH_MUL,          0,                           0                          },
 294     {WINED3D_SM1_OP_RCP,      1, 2, WINED3DSIH_RCP,          0,                           0                          },
 295     {WINED3D_SM1_OP_RSQ,      1, 2, WINED3DSIH_RSQ,          0,                           0                          },
 296     {WINED3D_SM1_OP_DP3,      1, 3, WINED3DSIH_DP3,          0,                           0                          },
 297     {WINED3D_SM1_OP_DP4,      1, 3, WINED3DSIH_DP4,          0,                           0                          },
 298     {WINED3D_SM1_OP_MIN,      1, 3, WINED3DSIH_MIN,          0,                           0                          },
 299     {WINED3D_SM1_OP_MAX,      1, 3, WINED3DSIH_MAX,          0,                           0                          },
 300     {WINED3D_SM1_OP_SLT,      1, 3, WINED3DSIH_SLT,          0,                           0                          },
 301     {WINED3D_SM1_OP_SGE,      1, 3, WINED3DSIH_SGE,          0,                           0                          },
 302     {WINED3D_SM1_OP_ABS,      1, 2, WINED3DSIH_ABS,          0,                           0                          },
 303     {WINED3D_SM1_OP_EXP,      1, 2, WINED3DSIH_EXP,          0,                           0                          },
 304     {WINED3D_SM1_OP_LOG,      1, 2, WINED3DSIH_LOG,          0,                           0                          },
 305     {WINED3D_SM1_OP_EXPP,     1, 2, WINED3DSIH_EXPP,         0,                           0                          },
 306     {WINED3D_SM1_OP_LOGP,     1, 2, WINED3DSIH_LOGP,         0,                           0                          },
 307     {WINED3D_SM1_OP_DST,      1, 3, WINED3DSIH_DST,          0,                           0                          },
 308     {WINED3D_SM1_OP_LRP,      1, 4, WINED3DSIH_LRP,          0,                           0                          },
 309     {WINED3D_SM1_OP_FRC,      1, 2, WINED3DSIH_FRC,          0,                           0                          },
 310     {WINED3D_SM1_OP_CND,      1, 4, WINED3DSIH_CND,          WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,4)},
 311     {WINED3D_SM1_OP_CMP,      1, 4, WINED3DSIH_CMP,          WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(3,0)},
 312     {WINED3D_SM1_OP_POW,      1, 3, WINED3DSIH_POW,          0,                           0                          },
 313     {WINED3D_SM1_OP_CRS,      1, 3, WINED3DSIH_CRS,          0,                           0                          },
 314     {WINED3D_SM1_OP_NRM,      1, 2, WINED3DSIH_NRM,          0,                           0                          },
 315     {WINED3D_SM1_OP_SINCOS,   1, 4, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
 316     {WINED3D_SM1_OP_SINCOS,   1, 2, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(3,0), -1                         },
 317     {WINED3D_SM1_OP_DP2ADD,   1, 4, WINED3DSIH_DP2ADD,       WINED3D_SHADER_VERSION(2,0), -1                         },
 318     /* Matrix */
 319     {WINED3D_SM1_OP_M4x4,     1, 3, WINED3DSIH_M4x4,         0,                           0                          },
 320     {WINED3D_SM1_OP_M4x3,     1, 3, WINED3DSIH_M4x3,         0,                           0                          },
 321     {WINED3D_SM1_OP_M3x4,     1, 3, WINED3DSIH_M3x4,         0,                           0                          },
 322     {WINED3D_SM1_OP_M3x3,     1, 3, WINED3DSIH_M3x3,         0,                           0                          },
 323     {WINED3D_SM1_OP_M3x2,     1, 3, WINED3DSIH_M3x2,         0,                           0                          },
 324     /* Register declarations */
 325     {WINED3D_SM1_OP_DCL,      0, 2, WINED3DSIH_DCL,          0,                           0                          },
 326     /* Flow control */
 327     {WINED3D_SM1_OP_REP,      0, 1, WINED3DSIH_REP,          WINED3D_SHADER_VERSION(2,1), -1                         },
 328     {WINED3D_SM1_OP_ENDREP,   0, 0, WINED3DSIH_ENDREP,       WINED3D_SHADER_VERSION(2,1), -1                         },
 329     {WINED3D_SM1_OP_IF,       0, 1, WINED3DSIH_IF,           WINED3D_SHADER_VERSION(2,1), -1                         },
 330     {WINED3D_SM1_OP_IFC,      0, 2, WINED3DSIH_IFC,          WINED3D_SHADER_VERSION(2,1), -1                         },
 331     {WINED3D_SM1_OP_ELSE,     0, 0, WINED3DSIH_ELSE,         WINED3D_SHADER_VERSION(2,1), -1                         },
 332     {WINED3D_SM1_OP_ENDIF,    0, 0, WINED3DSIH_ENDIF,        WINED3D_SHADER_VERSION(2,1), -1                         },
 333     {WINED3D_SM1_OP_BREAK,    0, 0, WINED3DSIH_BREAK,        WINED3D_SHADER_VERSION(2,1), -1                         },
 334     {WINED3D_SM1_OP_BREAKC,   0, 2, WINED3DSIH_BREAKC,       WINED3D_SHADER_VERSION(2,1), -1                         },
 335     {WINED3D_SM1_OP_BREAKP,   0, 1, WINED3DSIH_BREAKP,       0,                           0                          },
 336     {WINED3D_SM1_OP_CALL,     0, 1, WINED3DSIH_CALL,         WINED3D_SHADER_VERSION(2,1), -1                         },
 337     {WINED3D_SM1_OP_CALLNZ,   0, 2, WINED3DSIH_CALLNZ,       WINED3D_SHADER_VERSION(2,1), -1                         },
 338     {WINED3D_SM1_OP_LOOP,     0, 2, WINED3DSIH_LOOP,         WINED3D_SHADER_VERSION(3,0), -1                         },
 339     {WINED3D_SM1_OP_RET,      0, 0, WINED3DSIH_RET,          WINED3D_SHADER_VERSION(2,1), -1                         },
 340     {WINED3D_SM1_OP_ENDLOOP,  0, 0, WINED3DSIH_ENDLOOP,      WINED3D_SHADER_VERSION(3,0), -1                         },
 341     {WINED3D_SM1_OP_LABEL,    0, 1, WINED3DSIH_LABEL,        WINED3D_SHADER_VERSION(2,1), -1                         },
 342     /* Constant definitions */
 343     {WINED3D_SM1_OP_DEF,      1, 5, WINED3DSIH_DEF,          0,                           0                          },
 344     {WINED3D_SM1_OP_DEFB,     1, 2, WINED3DSIH_DEFB,         0,                           0                          },
 345     {WINED3D_SM1_OP_DEFI,     1, 5, WINED3DSIH_DEFI,         0,                           0                          },
 346     /* Texture */
 347     {WINED3D_SM1_OP_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD,     0,                           WINED3D_SHADER_VERSION(1,3)},
 348     {WINED3D_SM1_OP_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD,     WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
 349     {WINED3D_SM1_OP_TEXKILL,  1, 1, WINED3DSIH_TEXKILL,      WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(3,0)},
 350     {WINED3D_SM1_OP_TEX,      1, 1, WINED3DSIH_TEX,          0,                           WINED3D_SHADER_VERSION(1,3)},
 351     {WINED3D_SM1_OP_TEX,      1, 2, WINED3DSIH_TEX,          WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
 352     {WINED3D_SM1_OP_TEX,      1, 3, WINED3DSIH_TEX,          WINED3D_SHADER_VERSION(2,0), -1                         },
 353     {WINED3D_SM1_OP_TEXBEM,   1, 2, WINED3DSIH_TEXBEM,       0,                           WINED3D_SHADER_VERSION(1,3)},
 354     {WINED3D_SM1_OP_TEXBEML,  1, 2, WINED3DSIH_TEXBEML,      WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 355     {WINED3D_SM1_OP_TEXREG2AR,      1, 2, WINED3DSIH_TEXREG2AR,    WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 356     {WINED3D_SM1_OP_TEXREG2GB,      1, 2, WINED3DSIH_TEXREG2GB,    WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 357     {WINED3D_SM1_OP_TEXREG2RGB,     1, 2, WINED3DSIH_TEXREG2RGB,   WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
 358     {WINED3D_SM1_OP_TEXM3x2PAD,     1, 2, WINED3DSIH_TEXM3x2PAD,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 359     {WINED3D_SM1_OP_TEXM3x2TEX,     1, 2, WINED3DSIH_TEXM3x2TEX,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 360     {WINED3D_SM1_OP_TEXM3x3PAD,     1, 2, WINED3DSIH_TEXM3x3PAD,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 361     {WINED3D_SM1_OP_TEXM3x3DIFF,    1, 2, WINED3DSIH_TEXM3x3DIFF,  WINED3D_SHADER_VERSION(0,0), WINED3D_SHADER_VERSION(0,0)},
 362     {WINED3D_SM1_OP_TEXM3x3SPEC,    1, 3, WINED3DSIH_TEXM3x3SPEC,  WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 363     {WINED3D_SM1_OP_TEXM3x3VSPEC,   1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 364     {WINED3D_SM1_OP_TEXM3x3TEX,     1, 2, WINED3DSIH_TEXM3x3TEX,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
 365     {WINED3D_SM1_OP_TEXDP3TEX,      1, 2, WINED3DSIH_TEXDP3TEX,    WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
 366     {WINED3D_SM1_OP_TEXM3x2DEPTH,   1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3D_SHADER_VERSION(1,3), WINED3D_SHADER_VERSION(1,3)},
 367     {WINED3D_SM1_OP_TEXDP3,   1, 2, WINED3DSIH_TEXDP3,       WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
 368     {WINED3D_SM1_OP_TEXM3x3,  1, 2, WINED3DSIH_TEXM3x3,      WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
 369     {WINED3D_SM1_OP_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH,     WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
 370     {WINED3D_SM1_OP_BEM,      1, 3, WINED3DSIH_BEM,          WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
 371     {WINED3D_SM1_OP_DSX,      1, 2, WINED3DSIH_DSX,          WINED3D_SHADER_VERSION(2,1), -1                         },
 372     {WINED3D_SM1_OP_DSY,      1, 2, WINED3DSIH_DSY,          WINED3D_SHADER_VERSION(2,1), -1                         },
 373     {WINED3D_SM1_OP_TEXLDD,   1, 5, WINED3DSIH_TEXLDD,       WINED3D_SHADER_VERSION(2,1), -1                         },
 374     {WINED3D_SM1_OP_SETP,     1, 3, WINED3DSIH_SETP,         0,                           0                          },
 375     {WINED3D_SM1_OP_TEXLDL,   1, 3, WINED3DSIH_TEXLDL,       WINED3D_SHADER_VERSION(3,0), -1                         },
 376     {WINED3D_SM1_OP_PHASE,    0, 0, WINED3DSIH_PHASE,        0,                           0                          },
 377     {0,                       0, 0, WINED3DSIH_TABLE_SIZE,   0,                           0                          },
 378 };
 379
 380 /* Read a parameter opcode from the input stream,
 381  * and possibly a relative addressing token.
 382  * Return the number of tokens read */
 383 static int shader_get_param(const struct wined3d_sm1_data *priv, const DWORD *ptr, DWORD *token, DWORD *addr_token)
 384 {
 385     UINT count = 1;
 386
 387     *token = *ptr;
 388
 389     /* PS >= 3.0 have relative addressing (with token)
 390      * VS >= 2.0 have relative addressing (with token)
 391      * VS >= 1.0 < 2.0 have relative addressing (without token)
 392      * The version check below should work in general */
 393     if (*ptr & WINED3DSHADER_ADDRMODE_RELATIVE)
 394     {
 395         if (priv->shader_version.major < 2)
 396         {
 397             *addr_token = (1 << 31)
 398                     | ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2)
 399                     | ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT) & WINED3DSP_REGTYPE_MASK)
 400                     | (WINED3DSP_NOSWIZZLE << WINED3DSP_SWIZZLE_SHIFT);
 401         }
 402         else
 403         {
 404             *addr_token = *(ptr + 1);
 405             ++count;
 406         }
 407     }
 408
 409     return count;
 410 }
 411
 412 static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wined3d_sm1_data *priv, DWORD code)
 413 {
 414     DWORD shader_version = WINED3D_SHADER_VERSION(priv->shader_version.major, priv->shader_version.minor);
 415     const struct wined3d_sm1_opcode_info *opcode_table = priv->opcode_table;
 416     DWORD i = 0;
 417
 418     while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE)
 419     {
 420         if ((code & WINED3DSI_OPCODE_MASK) == opcode_table[i].opcode
 421                 && shader_version >= opcode_table[i].min_version
 422                 && (!opcode_table[i].max_version || shader_version <= opcode_table[i].max_version))
 423         {
 424             return &opcode_table[i];
 425         }
 426         ++i;
 427     }
 428
 429     FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
 430             code, code, code & WINED3DSI_OPCODE_MASK, shader_version);
 431
 432     return NULL;
 433 }
 434
 435 /* Return the number of parameters to skip for an opcode */
 436 static int shader_skip_opcode(const struct wined3d_sm1_data *priv,
 437         const struct wined3d_sm1_opcode_info *opcode_info, DWORD opcode_token)
 438 {
 439    /* Shaders >= 2.0 may contain address tokens, but fortunately they
 440     * have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
 441     return (priv->shader_version.major >= 2)
 442             ? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : opcode_info->param_count;
 443 }
 444
 445 static void shader_parse_src_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
 446         struct wined3d_shader_src_param *src)
 447 {
 448     src->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
 449             | ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
 450     src->reg.data_type = WINED3D_DATA_FLOAT;
 451     src->reg.idx[0].offset = param & WINED3DSP_REGNUM_MASK;
 452     src->reg.idx[0].rel_addr = rel_addr;
 453     src->reg.idx[1].offset = ~0U;
 454     src->reg.idx[1].rel_addr = NULL;
 455     src->swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 456     src->modifiers = (param & WINED3DSP_SRCMOD_MASK) >> WINED3DSP_SRCMOD_SHIFT;
 457 }
 458
 459 static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
 460         struct wined3d_shader_dst_param *dst)
 461 {
 462     dst->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
 463             | ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
 464     dst->reg.data_type = WINED3D_DATA_FLOAT;
 465     dst->reg.idx[0].offset = param & WINED3DSP_REGNUM_MASK;
 466     dst->reg.idx[0].rel_addr = rel_addr;
 467     dst->reg.idx[1].offset = ~0U;
 468     dst->reg.idx[1].rel_addr = NULL;
 469     dst->write_mask = (param & WINED3D_SM1_WRITEMASK_MASK) >> WINED3D_SM1_WRITEMASK_SHIFT;
 470     dst->modifiers = (param & WINED3DSP_DSTMOD_MASK) >> WINED3DSP_DSTMOD_SHIFT;
 471     dst->shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
 472 }
 473
 474 /* Read the parameters of an unrecognized opcode from the input stream
 475  * Return the number of tokens read.
 476  *
 477  * Note: This function assumes source or destination token format.
 478  * It will not work with specially-formatted tokens like DEF or DCL,
 479  * but hopefully those would be recognized */
 480 static int shader_skip_unrecognized(const struct wined3d_sm1_data *priv, const DWORD *ptr)
 481 {
 482     int tokens_read = 0;
 483     int i = 0;
 484
 485     /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
 486     while (*ptr & 0x80000000)
 487     {
 488         DWORD token, addr_token = 0;
 489         struct wined3d_shader_src_param rel_addr;
 490
 491         tokens_read += shader_get_param(priv, ptr, &token, &addr_token);
 492         ptr += tokens_read;
 493
 494         FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token, addr_token);
 495
 496         if (token & WINED3DSHADER_ADDRMODE_RELATIVE) shader_parse_src_param(addr_token, NULL, &rel_addr);
 497
 498         if (!i)
 499         {
 500             struct wined3d_shader_dst_param dst;
 501
 502             shader_parse_dst_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &dst);
 503             shader_dump_dst_param(&dst, &priv->shader_version);
 504         }
 505         else
 506         {
 507             struct wined3d_shader_src_param src;
 508
 509             shader_parse_src_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &src);
 510             shader_dump_src_param(&src, &priv->shader_version);
 511         }
 512         FIXME("\n");
 513         ++i;
 514     }
 515     return tokens_read;
 516 }
 517
 518 static void *shader_sm1_init(const DWORD *byte_code, const struct wined3d_shader_signature *output_signature)
 519 {
 520     struct wined3d_sm1_data *priv;
 521     BYTE major, minor;
 522
 523     major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
 524     minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
 525     if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 0))
 526     {
 527         WARN("Invalid shader version %u.%u (%#x).\n", major, minor, *byte_code);
 528         return NULL;
 529     }
 530
 531     priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv));
 532     if (!priv)
 533     {
 534         ERR("Failed to allocate private data\n");
 535         return NULL;
 536     }
 537
 538     if (output_signature)
 539     {
 540         FIXME("SM 1-3 shader shouldn't have output signatures.\n");
 541     }
 542
 543     switch (*byte_code >> 16)
 544     {
 545         case WINED3D_SM1_VS:
 546             priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
 547             priv->opcode_table = vs_opcode_table;
 548             break;
 549
 550         case WINED3D_SM1_PS:
 551             priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
 552             priv->opcode_table = ps_opcode_table;
 553             break;
 554
 555         default:
 556             FIXME("Unrecognized shader type %#x\n", *byte_code >> 16);
 557             HeapFree(GetProcessHeap(), 0, priv);
 558             return NULL;
 559     }
 560
 561     return priv;
 562 }
 563
 564 static void shader_sm1_free(void *data)
 565 {
 566     HeapFree(GetProcessHeap(), 0, data);
 567 }
 568
 569 static void shader_sm1_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
 570 {
 571     struct wined3d_sm1_data *priv = data;
 572     DWORD version_token;
 573
 574     version_token = *(*ptr)++;
 575     TRACE("version: 0x%08x\n", version_token);
 576
 577     priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(version_token);
 578     priv->shader_version.minor = WINED3D_SM1_VERSION_MINOR(version_token);
 579     *shader_version = priv->shader_version;
 580 }
 581
 582 static void shader_sm1_read_src_param(struct wined3d_sm1_data *priv, const DWORD **ptr,
 583         struct wined3d_shader_src_param *src_param, struct wined3d_shader_src_param *src_rel_addr)
 584 {
 585     DWORD token, addr_token;
 586
 587     *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
 588     if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
 589     {
 590         shader_parse_src_param(addr_token, NULL, src_rel_addr);
 591         shader_parse_src_param(token, src_rel_addr, src_param);
 592     }
 593     else
 594     {
 595         shader_parse_src_param(token, NULL, src_param);
 596     }
 597 }
 598
 599 static void shader_sm1_read_dst_param(struct wined3d_sm1_data *priv, const DWORD **ptr,
 600         struct wined3d_shader_dst_param *dst_param, struct wined3d_shader_src_param *dst_rel_addr)
 601 {
 602     DWORD token, addr_token;
 603
 604     *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
 605     if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
 606     {
 607         shader_parse_src_param(addr_token, NULL, dst_rel_addr);
 608         shader_parse_dst_param(token, dst_rel_addr, dst_param);
 609     }
 610     else
 611     {
 612         shader_parse_dst_param(token, NULL, dst_param);
 613     }
 614 }
 615
 616 static void shader_sm1_read_semantic(const DWORD **ptr, struct wined3d_shader_semantic *semantic)
 617 {
 618     DWORD usage_token = *(*ptr)++;
 619     DWORD dst_token = *(*ptr)++;
 620
 621     semantic->usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 622     semantic->usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 623     semantic->sampler_type = (usage_token & WINED3DSP_TEXTURETYPE_MASK) >> WINED3DSP_TEXTURETYPE_SHIFT;
 624     shader_parse_dst_param(dst_token, NULL, &semantic->reg);
 625 }
 626
 627 static void shader_sm1_read_immconst(const DWORD **ptr, struct wined3d_shader_src_param *src_param,
 628         enum wined3d_immconst_type type, enum wined3d_data_type data_type)
 629 {
 630     UINT count = type == WINED3D_IMMCONST_VEC4 ? 4 : 1;
 631     src_param->reg.type = WINED3DSPR_IMMCONST;
 632     src_param->reg.data_type = data_type;
 633     src_param->reg.idx[0].offset = ~0U;
 634     src_param->reg.idx[0].rel_addr = NULL;
 635     src_param->reg.idx[1].offset = ~0U;
 636     src_param->reg.idx[1].rel_addr = NULL;
 637     src_param->reg.immconst_type = type;
 638     memcpy(src_param->reg.immconst_data, *ptr, count * sizeof(DWORD));
 639     src_param->swizzle = WINED3DSP_NOSWIZZLE;
 640     src_param->modifiers = 0;
 641
 642     *ptr += count;
 643 }
 644
 645 static void shader_sm1_read_comment(const DWORD **ptr)
 646 {
 647     DWORD token = **ptr;
 648     const char *comment;
 649     UINT size;
 650
 651     while ((token & WINED3DSI_OPCODE_MASK) == WINED3D_SM1_OP_COMMENT)
 652     {
 653         size = (token & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
 654         comment = (const char *)++(*ptr);
 655         *ptr += size;
 656
 657         if (size > 1 && *(const DWORD *)comment == WINEMAKEFOURCC('T', 'E', 'X', 'T'))
 658         {
 659             const char *end = comment + size * sizeof(token);
 660             const char *p = comment + sizeof(token);
 661             const char *line = p;
 662
 663             TRACE("// TEXT\n");
 664             while (p != end)
 665             {
 666                 if (*p == '\n')
 667                 {
 668                     UINT len = p - line;
 669                     if (len && *(p - 1) == '\r') --len;
 670                     TRACE("// %s\n", debugstr_an(line, len));
 671                     line = ++p;
 672                 }
 673                 else ++p;
 674             }
 675             if (line != p)
 676                 TRACE("// %s\n", debugstr_an(line, p - line));
 677         }
 678         else if (size)
 679             TRACE("// %s\n", debugstr_an(comment, size * sizeof(token)));
 680         else
 681             break;
 682
 683         token = **ptr;
 684     }
 685 }
 686
 687 static void shader_sm1_read_instruction(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins)
 688 {
 689     const struct wined3d_sm1_opcode_info *opcode_info;
 690     struct wined3d_sm1_data *priv = data;
 691     DWORD opcode_token;
 692     unsigned int i;
 693     const DWORD *p;
 694
 695     shader_sm1_read_comment(ptr);
 696
 697     opcode_token = *(*ptr)++;
 698     if (!(opcode_info = shader_get_opcode(priv, opcode_token)))
 699     {
 700         FIXME("Unrecognized opcode: token=0x%08x.\n", opcode_token);
 701         ins->handler_idx = WINED3DSIH_TABLE_SIZE;
 702         *ptr += shader_skip_unrecognized(priv, *ptr);
 703         return;
 704     }
 705
 706     ins->handler_idx = opcode_info->handler_idx;
 707     ins->flags = (opcode_token & WINED3D_OPCODESPECIFICCONTROL_MASK) >> WINED3D_OPCODESPECIFICCONTROL_SHIFT;
 708     ins->coissue = opcode_token & WINED3DSI_COISSUE;
 709     ins->predicate = opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED ? &priv->pred_param : NULL;
 710     ins->dst_count = opcode_info->dst_count ? 1 : 0;
 711     ins->dst = &priv->dst_param;
 712     ins->src_count = opcode_info->param_count - opcode_info->dst_count;
 713     ins->src = priv->src_param;
 714
 715     p = *ptr;
 716     *ptr += shader_skip_opcode(priv, opcode_info, opcode_token);
 717
 718     if (ins->handler_idx == WINED3DSIH_DCL)
 719     {
 720         shader_sm1_read_semantic(&p, &ins->declaration.semantic);
 721     }
 722     else if (ins->handler_idx == WINED3DSIH_DEF)
 723     {
 724         shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
 725         shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_FLOAT);
 726     }
 727     else if (ins->handler_idx == WINED3DSIH_DEFI)
 728     {
 729         shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
 730         shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_INT);
 731     }
 732     else if (ins->handler_idx == WINED3DSIH_DEFB)
 733     {
 734         shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
 735         shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_SCALAR, WINED3D_DATA_UINT);
 736     }
 737     else
 738     {
 739         /* Destination token */
 740         if (ins->dst_count)
 741             shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
 742
 743         /* Predication token */
 744         if (ins->predicate)
 745             shader_sm1_read_src_param(priv, &p, &priv->pred_param, &priv->pred_rel_addr);
 746
 747         /* Other source tokens */
 748         for (i = 0; i < ins->src_count; ++i)
 749         {
 750             shader_sm1_read_src_param(priv, &p, &priv->src_param[i], &priv->src_rel_addr[i]);
 751         }
 752     }
 753 }
 754
 755 static BOOL shader_sm1_is_end(void *data, const DWORD **ptr)
 756 {
 757     shader_sm1_read_comment(ptr);
 758
 759     if (**ptr == WINED3DSP_END)
 760     {
 761         ++(*ptr);
 762         return TRUE;
 763     }
 764
 765     return FALSE;
 766 }
 767
 768 const struct wined3d_shader_frontend sm1_shader_frontend =
 769 {
 770     shader_sm1_init,
 771     shader_sm1_free,
 772     shader_sm1_read_header,
 773     shader_sm1_read_instruction,
 774     shader_sm1_is_end,
 775 };