git.oblomov.eu Git - wine/blob - dlls/d3dx9_36/tests/asm.c

   1 /*
   2  * Copyright (C) 2008 Stefan Dösinger
   3  * Copyright (C) 2009 Matteo Bruni
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #define COBJMACROS
  20 #include "wine/test.h"
  21
  22 #include <d3dx9.h>
  23
  24 #include "resources.h"
  25
  26 struct shader_test {
  27     const char *text;
  28     const DWORD bytes[128];
  29 };
  30
  31 static HRESULT create_file(const char *filename, const char *data, const unsigned int size)
  32 {
  33     DWORD received;
  34     HANDLE hfile;
  35
  36     hfile = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
  37     if(hfile == INVALID_HANDLE_VALUE) return HRESULT_FROM_WIN32(GetLastError());
  38
  39     if(WriteFile(hfile, data, size, &received, NULL))
  40     {
  41         CloseHandle(hfile);
  42         return D3D_OK;
  43     }
  44
  45     CloseHandle(hfile);
  46     return D3DERR_INVALIDCALL;
  47 }
  48
  49 static void dump_shader(DWORD *shader) {
  50     unsigned int i = 0, j = 0;
  51     do {
  52         trace("0x%08x ", shader[i]);
  53         j++;
  54         i++;
  55         if(j == 6) trace("\n");
  56     } while(shader[i - 1] != D3DSIO_END);
  57     if(j != 6) trace("\n");
  58 }
  59
  60 static void exec_tests(const char *name, struct shader_test tests[], unsigned int count) {
  61     HRESULT hr;
  62     DWORD *res;
  63     unsigned int i, j;
  64     BOOL diff;
  65     LPD3DXBUFFER shader, messages;
  66
  67     for(i = 0; i < count; i++) {
  68         /* D3DXAssembleShader sets messages to 0 if there aren't error messages */
  69         messages = NULL;
  70         hr = D3DXAssembleShader(tests[i].text, strlen(tests[i].text),
  71                                 NULL, NULL, D3DXSHADER_SKIPVALIDATION,
  72                                 &shader, &messages);
  73         ok(hr == D3D_OK, "Test %s, shader %d: D3DXAssembleShader failed with error 0x%x - %d\n", name, i, hr, hr & 0x0000FFFF);
  74         if(messages) {
  75             trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
  76             ID3DXBuffer_Release(messages);
  77         }
  78         if(FAILED(hr)) continue;
  79
  80         j = 0;
  81         diff = FALSE;
  82         res = ID3DXBuffer_GetBufferPointer(shader);
  83         while(res[j] != D3DSIO_END && tests[i].bytes[j] != D3DSIO_END) {
  84             if(res[j] != tests[i].bytes[j]) diff = TRUE;
  85             j++;
  86         };
  87         /* Both must have an end token */
  88         if(res[j] != tests[i].bytes[j]) diff = TRUE;
  89
  90         if(diff) {
  91             ok(FALSE, "Test %s, shader %d: Generated code differs\n", name, i);
  92             dump_shader(res);
  93         }
  94         ID3DXBuffer_Release(shader);
  95     }
  96 }
  97
  98 static void preproc_test(void) {
  99     struct shader_test tests[] = {
 100         {   /* shader 0 */
 101             "vs.1.1\r\n"
 102             "//some comments\r\n"
 103             "//other comments\n"
 104             "; yet another comment\r\n"
 105             "add r0, r0, r1\n",
 106             {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
 107         },
 108         {   /* shader 1 */
 109             "#line 1 \"vertex.vsh\"\n"
 110             "vs.1.1\n",
 111             {0xfffe0101, 0x0000ffff}
 112         },
 113         {   /* shader 2 */
 114             "#define REG 1 + 2 +\\\n"
 115             "3 + 4\n"
 116             "vs.1.1\n"
 117             "mov r0, c0[ REG ]\n",
 118             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4000a, 0x0000ffff}
 119         },
 120     };
 121
 122     exec_tests("preproc", tests, sizeof(tests) / sizeof(tests[0]));
 123 }
 124
 125 static void ps_1_1_test(void) {
 126     struct shader_test tests[] = {
 127         {   /* shader 0 */
 128             "ps.1.1\r\n"
 129             "tex t0\r\n"
 130             "add r0.rgb, r0, r1\r\n"
 131             "+mov r0.a, t0\r\n",
 132             {0xffff0101, 0x00000042, 0xb00f0000, 0x00000002, 0x80070000, 0x80e40000,
 133              0x80e40001, 0x40000001, 0x80080000, 0xb0e40000, 0x0000ffff}
 134         },
 135         {   /* shader 1 */
 136             "ps.1.1\n"
 137             "mov_d4 r0, r1\n",
 138             {0xffff0101, 0x00000001, 0x8e0f0000, 0x80e40001, 0x0000ffff}
 139         },
 140     };
 141
 142     exec_tests("ps_1_1", tests, sizeof(tests) / sizeof(tests[0]));
 143 }
 144
 145 static void vs_1_1_test(void) {
 146     struct shader_test tests[] = {
 147         /* Basic instruction tests */
 148         {   /* shader 0 */
 149             "vs_1_1\n"
 150             "add r0, r1, r2\n",
 151             {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 152         },
 153         {   /* shader 1 */
 154             "vs_1_1\n"
 155             "nop\n",
 156             {0xfffe0101, 0x00000000, 0x0000ffff}
 157         },
 158         /* Output register tests */
 159         {   /* shader 2 */
 160             "vs_1_1\n"
 161             "mov oPos, c0\n",
 162             {0xfffe0101, 0x00000001, 0xc00f0000, 0xa0e40000, 0x0000ffff}
 163         },
 164         {   /* shader 3 */
 165             "vs_1_1\n"
 166             "mov oT0, c0\n",
 167             {0xfffe0101, 0x00000001, 0xe00f0000, 0xa0e40000, 0x0000ffff}
 168         },
 169         {   /* shader 4 */
 170             "vs_1_1\n"
 171             "mov oT5, c0\n",
 172             {0xfffe0101, 0x00000001, 0xe00f0005, 0xa0e40000, 0x0000ffff}
 173         },
 174         {   /* shader 5 */
 175             "vs_1_1\n"
 176             "mov oD0, c0\n",
 177             {0xfffe0101, 0x00000001, 0xd00f0000, 0xa0e40000, 0x0000ffff}
 178         },
 179         {   /* shader 6 */
 180             "vs_1_1\n"
 181             "mov oD1, c0\n",
 182             {0xfffe0101, 0x00000001, 0xd00f0001, 0xa0e40000, 0x0000ffff}
 183         },
 184         {   /* shader 7 */
 185             "vs_1_1\n"
 186             "mov oFog, c0.x\n",
 187             {0xfffe0101, 0x00000001, 0xc00f0001, 0xa0000000, 0x0000ffff}
 188         },
 189         {   /* shader 8 */
 190             "vs_1_1\n"
 191             "mov oPts, c0.x\n",
 192             {0xfffe0101, 0x00000001, 0xc00f0002, 0xa0000000, 0x0000ffff}
 193         },
 194         /* A bunch of tests for declarations */
 195         {   /* shader 9 */
 196             "vs_1_1\n"
 197             "dcl_position0 v0",
 198             {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000ffff}
 199         },
 200         {   /* shader 10 */
 201             "vs_1_1\n"
 202             "dcl_position v1",
 203             {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0001, 0x0000ffff}
 204         },
 205         {   /* shader 11 */
 206             "vs_1_1\n"
 207             "dcl_normal12 v15",
 208             {0xfffe0101, 0x0000001f, 0x800c0003, 0x900f000f, 0x0000ffff}
 209         },
 210         {   /* shader 12 */
 211             "vs_1_1\n"
 212             "add r0, v0, v1\n",
 213             {0xfffe0101, 0x00000002, 0x800f0000, 0x90e40000, 0x90e40001, 0x0000ffff}
 214         },
 215         {   /* shader 13 */
 216             "vs_1_1\n"
 217             "def c12, 0, -1, -0.5, 1024\n",
 218             {0xfffe0101, 0x00000051, 0xa00f000c, 0x00000000, 0xbf800000, 0xbf000000,
 219              0x44800000, 0x0000ffff}
 220         },
 221         {   /* shader 14: writemasks, swizzles */
 222             "vs_1_1\n"
 223             "dp4 r0.xw, r1.wzyx, r2.xxww\n",
 224             {0xfffe0101, 0x00000009, 0x80090000, 0x801b0001, 0x80f00002, 0x0000ffff}
 225         },
 226         {   /* shader 15: negation input modifier. Other modifiers not supprted in vs_1_1 */
 227             "vs_1_1\n"
 228             "add r0, -r0.x, -r1\n",
 229             {0xfffe0101, 0x00000002, 0x800f0000, 0x81000000, 0x81e40001, 0x0000ffff}
 230         },
 231         {   /* shader 16: relative addressing */
 232             "vs_1_1\n"
 233             "mov r0, c0[a0.x]\n",
 234             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42000, 0x0000ffff}
 235         },
 236         {   /* shader 17: relative addressing */
 237             "vs_1_1\n"
 238             "mov r0, c1[a0.x + 2]\n",
 239             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42003, 0x0000ffff}
 240         },
 241         {   /* shader 18 */
 242             "vs_1_1\n"
 243             "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
 244             {0xfffe0101, 0x00000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
 245              0x3f000000, 0x0000ffff}
 246         },
 247         /* Other relative addressing tests */
 248         {   /* shader 19 */
 249             "vs_1_1\n"
 250             "mov r0, c[ a0.x + 12 ]\n",
 251             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200c, 0x0000ffff}
 252         },
 253         {   /* shader 20 */
 254             "vs_1_1\n"
 255             "mov r0, c[ 2 + a0.x ]\n",
 256             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42002, 0x0000ffff}
 257         },
 258         {   /* shader 21 */
 259             "vs_1_1\n"
 260             "mov r0, c[ 2 + a0.x + 12 ]\n",
 261             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200e, 0x0000ffff}
 262         },
 263         {   /* shader 22 */
 264             "vs_1_1\n"
 265             "mov r0, c[ 2 + 10 + 12 ]\n",
 266             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40018, 0x0000ffff}
 267         },
 268         {   /* shader 23 */
 269             "vs_1_1\n"
 270             "mov r0, c4[ 2 ]\n",
 271             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40006, 0x0000ffff}
 272         },
 273         {   /* shader 24 */
 274             "vs_1_1\n"
 275             "rcp r0, v0.x\n",
 276             {0xfffe0101, 0x00000006, 0x800f0000, 0x90000000, 0x0000ffff}
 277         },
 278         {   /* shader 25 */
 279             "vs_1_1\n"
 280             "rsq r0, v0.x\n",
 281             {0xfffe0101, 0x00000007, 0x800f0000, 0x90000000, 0x0000ffff}
 282         },
 283     };
 284
 285     exec_tests("vs_1_1", tests, sizeof(tests) / sizeof(tests[0]));
 286 }
 287
 288 static void ps_1_3_test(void) {
 289     struct shader_test tests[] = {
 290         /* Basic instruction tests */
 291         {   /* shader 0 */
 292             "ps_1_3\n"
 293             "mov r0, r1\n",
 294             {0xffff0103, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
 295         },
 296         {   /* shader 1 */
 297             "ps_1_3\n"
 298             "add r0, r1, r0\n",
 299             {0xffff0103, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40000, 0x0000ffff}
 300         },
 301         /* Color interpolator tests */
 302         {   /* shader 2 */
 303             "ps_1_3\n"
 304             "mov r0, v0\n",
 305             {0xffff0103, 0x00000001, 0x800f0000, 0x90e40000, 0x0000ffff}
 306         },
 307         {   /* shader 3 */
 308             "ps_1_3\n"
 309             "mov r0, v1\n",
 310             {0xffff0103, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
 311         },
 312         /* Texture sampling instructions */
 313         {   /* shader 4 */
 314             "ps_1_3\n"
 315             "tex t0\n",
 316             {0xffff0103, 0x00000042, 0xb00f0000, 0x0000ffff}
 317         },
 318         {   /* shader 5 */
 319             "ps_1_3\n"
 320             "tex t0\n"
 321             "texreg2ar t1, t0\n",
 322             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000045, 0xb00f0001, 0xb0e40000,
 323              0x0000ffff}
 324         },
 325         {   /* shader 6 */
 326             "ps_1_3\n"
 327             "tex t0\n"
 328             "texreg2gb t1, t0\n",
 329             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000046, 0xb00f0001, 0xb0e40000,
 330              0x0000ffff}
 331         },
 332         {   /* shader 7 */
 333             "ps_1_3\n"
 334             "tex t0\n"
 335             "texreg2rgb t1, t0\n",
 336             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000052, 0xb00f0001, 0xb0e40000,
 337              0x0000ffff}
 338         },
 339         {   /* shader 8 */
 340             "ps_1_3\n"
 341             "cnd r0, r1, r0, v0\n",
 342             {0xffff0103, 0x00000050, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
 343              0x0000ffff}
 344         },
 345         {   /* shader 9 */
 346             "ps_1_3\n"
 347             "cmp r0, r1, r0, v0\n",
 348             {0xffff0103, 0x00000058, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
 349              0x0000ffff}
 350         },
 351         {   /* shader 10 */
 352             "ps_1_3\n"
 353             "texkill t0\n",
 354             {0xffff0103, 0x00000041, 0xb00f0000, 0x0000ffff}
 355         },
 356         {   /* shader 11 */
 357             "ps_1_3\n"
 358             "tex t0\n"
 359             "texm3x2pad t1, t0\n"
 360             "texm3x2tex t2, t0\n",
 361             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
 362              0x00000048, 0xb00f0002, 0xb0e40000, 0x0000ffff}
 363         },
 364         {   /* shader 12 */
 365             "ps_1_3\n"
 366             "tex t0\n"
 367             "texm3x2pad t1, t0\n"
 368             "texm3x2depth t2, t0\n",
 369             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
 370              0x00000054, 0xb00f0002, 0xb0e40000, 0x0000ffff}
 371         },
 372         {   /* shader 13 */
 373             "ps_1_3\n"
 374             "tex t0\n"
 375             "texbem t1, t0\n",
 376             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000043, 0xb00f0001, 0xb0e40000,
 377              0x0000ffff}
 378         },
 379         {   /* shader 14 */
 380             "ps_1_3\n"
 381             "tex t0\n"
 382             "texbeml t1, t0\n",
 383             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000044, 0xb00f0001, 0xb0e40000,
 384              0x0000ffff}
 385         },
 386         {   /* shader 15 */
 387             "ps_1_3\n"
 388             "tex t0\n"
 389             "texdp3tex t1, t0\n",
 390             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb00f0001, 0xb0e40000,
 391              0x0000ffff}
 392         },
 393         {   /* shader 16 */
 394             "ps_1_3\n"
 395             "tex t0\n"
 396             "texdp3 t1, t0\n",
 397             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000055, 0xb00f0001, 0xb0e40000,
 398              0x0000ffff}
 399         },
 400         {   /* shader 17 */
 401             "ps_1_3\n"
 402             "tex t0\n"
 403             "texm3x3pad t1, t0\n"
 404             "texm3x3pad t2, t0\n"
 405             "texm3x3tex t3, t0\n",
 406             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 407              0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004a, 0xb00f0003, 0xb0e40000,
 408              0x0000ffff}
 409         },
 410         {   /* shader 18 */
 411             "ps_1_3\n"
 412             "tex t0\n"
 413             "texm3x3pad t1, t0\n"
 414             "texm3x3pad t2, t0\n"
 415             "texm3x3 t3, t0\n",
 416             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 417              0x00000049, 0xb00f0002, 0xb0e40000, 0x00000056, 0xb00f0003, 0xb0e40000,
 418              0x0000ffff}
 419         },
 420         {   /* shader 19 */
 421             "ps_1_3\n"
 422             "tex t0\n"
 423             "texm3x3pad t1, t0\n"
 424             "texm3x3pad t2, t0\n"
 425             "texm3x3spec t3, t0, c0\n",
 426             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 427              0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004c, 0xb00f0003, 0xb0e40000,
 428              0xa0e40000, 0x0000ffff}
 429         },
 430         {   /* shader 20 */
 431             "ps_1_3\n"
 432             "tex t0\n"
 433             "texm3x3pad t1, t0\n"
 434             "texm3x3pad t2, t0\n"
 435             "texm3x3vspec t3, t0\n",
 436             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 437              0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004d, 0xb00f0003, 0xb0e40000,
 438              0x0000ffff}
 439         },
 440         {   /* shader 21 */
 441             "ps_1_3\n"
 442             "texcoord t0\n",
 443             {0xffff0103, 0x00000040, 0xb00f0000, 0x0000ffff}
 444         },
 445         /* Modifiers, shifts */
 446         {   /* shader 22 */
 447             "ps_1_3\n"
 448             "mov_x2_sat r0, 1 - r1\n",
 449             {0xffff0103, 0x00000001, 0x811f0000, 0x86e40001, 0x0000ffff}
 450         },
 451         {   /* shader 23 */
 452             "ps_1_3\n"
 453             "mov_d8 r0, -r1\n",
 454             {0xffff0103, 0x00000001, 0x8d0f0000, 0x81e40001, 0x0000ffff}
 455         },
 456         {   /* shader 24 */
 457             "ps_1_3\n"
 458             "mov_sat r0, r1_bx2\n",
 459             {0xffff0103, 0x00000001, 0x801f0000, 0x84e40001, 0x0000ffff}
 460         },
 461         {   /* shader 25 */
 462             "ps_1_3\n"
 463             "mov_sat r0, r1_bias\n",
 464             {0xffff0103, 0x00000001, 0x801f0000, 0x82e40001, 0x0000ffff}
 465         },
 466         {   /* shader 26 */
 467             "ps_1_3\n"
 468             "mov_sat r0, -r1_bias\n",
 469             {0xffff0103, 0x00000001, 0x801f0000, 0x83e40001, 0x0000ffff}
 470         },
 471         {   /* shader 27 */
 472             "ps_1_3\n"
 473             "mov_sat r0, -r1_bx2\n",
 474             {0xffff0103, 0x00000001, 0x801f0000, 0x85e40001, 0x0000ffff}
 475         },
 476         {   /* shader 28 */
 477             "ps_1_3\n"
 478             "mov_sat r0, -r1_x2\n",
 479             {0xffff0103, 0x00000001, 0x801f0000, 0x88e40001, 0x0000ffff}
 480         },
 481         {   /* shader 29 */
 482             "ps_1_3\n"
 483             "mov_x4_sat r0.a, -r1_bx2.a\n",
 484             {0xffff0103, 0x00000001, 0x82180000, 0x85ff0001, 0x0000ffff}
 485         },
 486         {   /* shader 30 */
 487             "ps_1_3\n"
 488             "texcoord_x2 t0\n",
 489             {0xffff0103, 0x00000040, 0xb10f0000, 0x0000ffff}
 490         },
 491         {   /* shader 31 */
 492             "ps_1_3\n"
 493             "tex_x2 t0\n",
 494             {0xffff0103, 0x00000042, 0xb10f0000, 0x0000ffff}
 495         },
 496         {   /* shader 32 */
 497             "ps_1_3\n"
 498             "texreg2ar_x4 t0, t1\n",
 499             {0xffff0103, 0x00000045, 0xb20f0000, 0xb0e40001, 0x0000ffff}
 500         },
 501         {   /* shader 33 */
 502             "ps_1_3\n"
 503             "texbem_d4 t1, t0\n",
 504             {0xffff0103, 0x00000043, 0xbe0f0001, 0xb0e40000, 0x0000ffff}
 505         },
 506         {   /* shader 34 */
 507             "ps_1_3\n"
 508             "tex t0\n"
 509             "texm3x3pad_x2 t1, t0\n"
 510             "texm3x3pad_x2 t2, t0\n"
 511             "texm3x3tex_x2 t3, t0\n",
 512             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb10f0001, 0xb0e40000,
 513              0x00000049, 0xb10f0002, 0xb0e40000, 0x0000004a, 0xb10f0003, 0xb0e40000,
 514              0x0000ffff}
 515         },
 516         {   /* shader 35 */
 517             "ps_1_3\n"
 518             "tex t0\n"
 519             "texdp3tex_x8 t1, t0\n",
 520             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb30f0001, 0xb0e40000,
 521              0x0000ffff}
 522         },
 523     };
 524
 525     exec_tests("ps_1_3", tests, sizeof(tests) / sizeof(tests[0]));
 526 }
 527
 528 static void ps_1_4_test(void) {
 529     struct shader_test tests[] = {
 530         /* Basic instruction tests */
 531         {   /* shader 0 */
 532             "ps_1_4\n"
 533             "mov r0, r1\n",
 534             {0xffff0104, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
 535         },
 536         {   /* shader 1 */
 537             "ps_1_4\n"
 538             "mov r0, r5\n",
 539             {0xffff0104, 0x00000001, 0x800f0000, 0x80e40005, 0x0000ffff}
 540         },
 541         {   /* shader 2 */
 542             "ps_1_4\n"
 543             "mov r0, c7\n",
 544             {0xffff0104, 0x00000001, 0x800f0000, 0xa0e40007, 0x0000ffff}
 545         },
 546         {   /* shader 3 */
 547             "ps_1_4\n"
 548             "mov r0, v1\n",
 549             {0xffff0104, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
 550         },
 551         {   /* shader 4 */
 552             "ps_1_4\n"
 553             "phase\n",
 554             {0xffff0104, 0x0000fffd, 0x0000ffff}
 555         },
 556         {   /* shader 5 */
 557             "ps_1_4\n"
 558             "texcrd r0, t0\n",
 559             {0xffff0104, 0x00000040, 0x800f0000, 0xb0e40000, 0x0000ffff}
 560         },
 561         {   /* shader 6 */
 562             "ps_1_4\n"
 563             "texcrd r4, t3\n",
 564             {0xffff0104, 0x00000040, 0x800f0004, 0xb0e40003, 0x0000ffff}
 565         },
 566         {   /* shader 7 */
 567             "ps_1_4\n"
 568             "texcrd_sat r4, t3\n",
 569             {0xffff0104, 0x00000040, 0x801f0004, 0xb0e40003, 0x0000ffff}
 570         },
 571         {   /* shader 8 */
 572             "ps_1_4\n"
 573             "texld r0, t0\n",
 574             {0xffff0104, 0x00000042, 0x800f0000, 0xb0e40000, 0x0000ffff}
 575         },
 576         {   /* shader 9 */
 577             "ps_1_4\n"
 578             "texld r1, t4\n",
 579             {0xffff0104, 0x00000042, 0x800f0001, 0xb0e40004, 0x0000ffff}
 580         },
 581         {   /* shader 10 */
 582             "ps_1_4\n"
 583             "texld r5, r0\n",
 584             {0xffff0104, 0x00000042, 0x800f0005, 0x80e40000, 0x0000ffff}
 585         },
 586         {   /* shader 11 */
 587             "ps_1_4\n"
 588             "texld r5, c0\n", /* Assembly succeeds, validation fails */
 589             {0xffff0104, 0x00000042, 0x800f0005, 0xa0e40000, 0x0000ffff}
 590         },
 591         {   /* shader 12 */
 592             "ps_1_4\n"
 593             "texld r5, r2_dz\n",
 594             {0xffff0104, 0x00000042, 0x800f0005, 0x89e40002, 0x0000ffff}
 595         },
 596         {   /* shader 13 */
 597             "ps_1_4\n"
 598             "bem r1.rg, c0, r0\n",
 599             {0xffff0104, 0x00000059, 0x80030001, 0xa0e40000, 0x80e40000, 0x0000ffff}
 600         },
 601         {   /* shader 14 */
 602             "ps_1_4\n"
 603             "texdepth r5\n",
 604             {0xffff0104, 0x00000057, 0x800f0005, 0x0000ffff}
 605         },
 606         {   /* shader 15 */
 607             "ps_1_4\n"
 608             "add r0, r1, r2_bx2\n",
 609             {0xffff0104, 0x00000002, 0x800f0000, 0x80e40001, 0x84e40002, 0x0000ffff}
 610         },
 611         {   /* shader 16 */
 612             "ps_1_4\n"
 613             "add_x4 r0, r1, r2\n",
 614             {0xffff0104, 0x00000002, 0x820f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 615         },
 616         {   /* shader 17 */
 617             "ps_1_4\n"
 618             "add r0.rgb, r1, r2\n"
 619             "+add r0.a, r1, r2\n",
 620             {0xffff0104, 0x00000002, 0x80070000, 0x80e40001, 0x80e40002, 0x40000002,
 621              0x80080000, 0x80e40001, 0x80e40002, 0x0000ffff}
 622         },
 623         {   /* shader 18 */
 624             "ps_1_4\n"
 625             "texdepth_x2 r5\n",
 626             {0xffff0104, 0x00000057, 0x810f0005, 0x0000ffff}
 627         },
 628         {   /* shader 19 */
 629             "ps_1_4\n"
 630             "bem_d2 r1, c0, r0\n",
 631             {0xffff0104, 0x00000059, 0x8f0f0001, 0xa0e40000, 0x80e40000, 0x0000ffff}
 632         },
 633         {   /* shader 20 */
 634             "ps_1_4\n"
 635             "texkill t0\n",
 636             {0xffff0104, 0x00000041, 0xb00f0000, 0x0000ffff}
 637         },
 638         {   /* shader 21 */
 639             "ps_1_4\n"
 640             "texkill r0\n",
 641             {0xffff0104, 0x00000041, 0x800f0000, 0x0000ffff}
 642         },
 643     };
 644
 645     exec_tests("ps_1_4", tests, sizeof(tests) / sizeof(tests[0]));
 646 }
 647
 648 static void vs_2_0_test(void) {
 649     struct shader_test tests[] = {
 650         /* Basic instruction tests */
 651         {   /* shader 0 */
 652             "vs_2_0\n"
 653             "mov r0, r1\n",
 654             {0xfffe0200, 0x02000001, 0x800f0000, 0x80e40001, 0x0000ffff}
 655         },
 656         {   /* shader 1 */
 657             "vs_2_0\n"
 658             "lrp r0, v0, c0, r1\n",
 659             {0xfffe0200, 0x04000012, 0x800f0000, 0x90e40000, 0xa0e40000, 0x80e40001,
 660              0x0000ffff}
 661         },
 662         {   /* shader 2 */
 663             "vs_2_0\n"
 664             "dp4 oPos, v0, c0\n",
 665             {0xfffe0200, 0x03000009, 0xc00f0000, 0x90e40000, 0xa0e40000, 0x0000ffff}
 666         },
 667         {   /* shader 3 */
 668             "vs_2_0\n"
 669             "mov r0, c0[a0.x]\n",
 670             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0000000, 0x0000ffff}
 671         },
 672         {   /* shader 4 */
 673             "vs_2_0\n"
 674             "mov r0, c0[a0.y]\n",
 675             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0550000, 0x0000ffff}
 676         },
 677         {   /* shader 5 */
 678             "vs_2_0\n"
 679             "mov r0, c0[a0.z]\n",
 680             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0aa0000, 0x0000ffff}
 681         },
 682         {   /* shader 6 */
 683             "vs_2_0\n"
 684             "mov r0, c0[a0.w]\n",
 685             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0ff0000, 0x0000ffff}
 686         },
 687         {   /* shader 7 */
 688             "vs_2_0\n"
 689             "mov r0, c0[a0.w].x\n",
 690             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0002000, 0xb0ff0000, 0x0000ffff}
 691         },
 692         {   /* shader 8 */
 693             "vs_2_0\n"
 694             "mov r0, -c0[a0.w+5].x\n",
 695             {0xfffe0200, 0x03000001, 0x800f0000, 0xa1002005, 0xb0ff0000, 0x0000ffff}
 696         },
 697         {   /* shader 9 */
 698             "vs_2_0\n"
 699             "mov r0, c0[a0]\n",
 700             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0e40000, 0x0000ffff}
 701         },
 702         {   /* shader 10 */
 703             "vs_2_0\n"
 704             "mov r0, c0[a0.xyww]\n",
 705             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0f40000, 0x0000ffff}
 706         },
 707         {   /* shader 11 */
 708             "vs_2_0\n"
 709             "add r0, c0[a0.x], c1[a0.y]\n", /* validation would fail on this line */
 710             {0xfffe0200, 0x05000002, 0x800f0000, 0xa0e42000, 0xb0000000, 0xa0e42001,
 711              0xb0550000, 0x0000ffff}
 712         },
 713         {   /* shader 12 */
 714             "vs_2_0\n"
 715             "rep i0\n"
 716             "endrep\n",
 717             {0xfffe0200, 0x01000026, 0xf0e40000, 0x00000027, 0x0000ffff}
 718         },
 719         {   /* shader 13 */
 720             "vs_2_0\n"
 721             "if b0\n"
 722             "else\n"
 723             "endif\n",
 724             {0xfffe0200, 0x01000028, 0xe0e40800, 0x0000002a, 0x0000002b, 0x0000ffff}
 725         },
 726         {   /* shader 14 */
 727             "vs_2_0\n"
 728             "loop aL, i0\n"
 729             "endloop\n",
 730             {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x0000001d, 0x0000ffff}
 731         },
 732         {   /* shader 15 */
 733             "vs_2_0\n"
 734             "nrm r0, c0\n",
 735             {0xfffe0200, 0x02000024, 0x800f0000, 0xa0e40000, 0x0000ffff}
 736         },
 737         {   /* shader 16 */
 738             "vs_2_0\n"
 739             "crs r0, r1, r2\n",
 740             {0xfffe0200, 0x03000021, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 741         },
 742         {   /* shader 17 */
 743             "vs_2_0\n"
 744             "sgn r0, r1, r2, r3\n",
 745             {0xfffe0200, 0x04000022, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
 746              0x0000ffff}
 747         },
 748         {   /* shader 18 */
 749             "vs_2_0\n"
 750             "sincos r0, r1, r2, r3\n",
 751             {0xfffe0200, 0x04000025, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
 752              0x0000ffff}
 753         },
 754         {   /* shader 19 */
 755             "vs_2_0\n"
 756             "pow r0, r1, r2\n",
 757             {0xfffe0200, 0x03000020, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 758         },
 759         {   /* shader 20 */
 760             "vs_2_0\n"
 761             "mova a0.y, c0.z\n",
 762             {0xfffe0200, 0x0200002e, 0xb0020000, 0xa0aa0000, 0x0000ffff}
 763         },
 764         {   /* shader 21 */
 765             "vs_2_0\n"
 766             "defb b0, true\n"
 767             "defb b1, false\n",
 768             {0xfffe0200, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
 769              0x00000000, 0x0000ffff}
 770         },
 771         {   /* shader 22 */
 772             "vs_2_0\n"
 773             "defi i0, -1, 1, 10, 0\n"
 774             "defi i1, 0, 40, 30, 10\n",
 775             {0xfffe0200, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
 776              0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
 777              0x0000000a, 0x0000ffff}
 778         },
 779         {   /* shader 23 */
 780             "vs_2_0\n"
 781             "loop aL, i0\n"
 782             "mov r0, c0[aL]\n"
 783             "endloop\n",
 784             {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
 785              0xa0e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
 786         },
 787         {   /* shader 24 */
 788             "vs_2_0\n"
 789             "call l0\n"
 790             "ret\n"
 791             "label l0\n"
 792             "ret\n",
 793             {0xfffe0200, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
 794              0x0000001c, 0x0000ffff}
 795         },
 796         {   /* shader 25 */
 797             "vs_2_0\n"
 798             "callnz l0, b0\n"
 799             "ret\n"
 800             "label l0\n"
 801             "ret\n",
 802             {0xfffe0200, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
 803              0xa0e41000, 0x0000001c, 0x0000ffff}
 804         },
 805         {   /* shader 26 */
 806             "vs_2_0\n"
 807             "callnz l0, !b0\n"
 808             "ret\n"
 809             "label l0\n"
 810             "ret\n",
 811             {0xfffe0200, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
 812              0xa0e41000, 0x0000001c, 0x0000ffff}
 813         },
 814         {   /* shader 27 */
 815             "vs_2_0\n"
 816             "if !b0\n"
 817             "else\n"
 818             "endif\n",
 819             {0xfffe0200, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
 820         },
 821         {   /* shader 28 */
 822             "vs_2_0\n"
 823             "call l3\n"
 824             "ret\n"
 825             "label l3\n"
 826             "ret\n",
 827             {0xfffe0200, 0x01000019, 0xa0e41003, 0x0000001c, 0x0100001e, 0xa0e41003, 0x0000001c, 0x0000ffff}
 828         },
 829         {   /* shader 29: labels up to 2047 are accepted even in vs_2_0 */
 830             "vs_2_0\n"
 831             "call l2047\n",
 832             {0xfffe0200, 0x01000019, 0xa0e417ff, 0x0000ffff}
 833         },
 834     };
 835
 836     exec_tests("vs_2_0", tests, sizeof(tests) / sizeof(tests[0]));
 837 }
 838
 839 static void vs_2_x_test(void) {
 840     struct shader_test tests[] = {
 841         {   /* shader 0 */
 842             "vs_2_x\n"
 843             "rep i0\n"
 844             "break\n"
 845             "endrep\n",
 846             {0xfffe0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
 847         },
 848         {   /* shader 1 */
 849             "vs_2_x\n"
 850             "if_ge r0, r1\n"
 851             "endif\n",
 852             {0xfffe0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
 853         },
 854         {   /* shader 2 */
 855             "vs_2_x\n"
 856             "rep i0\n"
 857             "break_ne r0, r1\n"
 858             "endrep",
 859             {0xfffe0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
 860              0x00000027, 0x0000ffff}
 861         },
 862
 863         /* predicates */
 864         {   /* shader 3 */
 865             "vs_2_x\n"
 866             "setp_gt p0, r0, r1\n"
 867             "(!p0) add r2, r2, r3\n",
 868             {0xfffe0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
 869              0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
 870         },
 871         {   /* shader 4 */
 872             "vs_2_x\n"
 873             "if p0.x\n"
 874             "else\n"
 875             "endif\n",
 876             {0xfffe0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
 877         },
 878         {   /* shader 5 */
 879             "vs_2_x\n"
 880             "callnz l0, !p0.z\n"
 881             "ret\n"
 882             "label l0\n"
 883             "ret\n",
 884             {0xfffe0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
 885              0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
 886         },
 887         {   /* shader 6 */
 888             "vs_2_x\n"
 889             "rep i0\n"
 890             "breakp p0.w\n"
 891             "endrep\n",
 892             {0xfffe0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
 893              0x00000027, 0x0000ffff}
 894         },
 895     };
 896
 897     exec_tests("vs_2_x", tests, sizeof(tests) / sizeof(tests[0]));
 898 }
 899
 900 static void ps_2_0_test(void) {
 901     struct shader_test tests[] = {
 902         {   /* shader 0 */
 903             "ps_2_0\n"
 904             "dcl_2d s0\n",
 905             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
 906         },
 907         {   /* shader 1 */
 908             "ps_2_0\n"
 909             "dcl_cube s0\n",
 910             {0xffff0200, 0x0200001f, 0x98000000, 0xa00f0800, 0x0000ffff}
 911         },
 912         {   /* shader 2 */
 913             "ps_2_0\n"
 914             "dcl_volume s0\n",
 915             {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0000ffff}
 916         },
 917         {   /* shader 3 */
 918             "ps_2_0\n"
 919             "dcl_volume s0\n"
 920             "dcl_cube s1\n"
 921             "dcl_2d s2\n",
 922             {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0200001f, 0x98000000,
 923              0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x0000ffff}
 924         },
 925         {   /* shader 4 */
 926             "ps_2_0\n"
 927             "mov r0, t0\n",
 928             {0xffff0200, 0x02000001, 0x800f0000, 0xb0e40000, 0x0000ffff}
 929         },
 930         {   /* shader 5 */
 931             "ps_2_0\n"
 932             "dcl_2d s2\n"
 933             "texld r0, t1, s2\n",
 934             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
 935              0xb0e40001, 0xa0e40802, 0x0000ffff}
 936         },
 937         {   /* shader 6 */
 938             "ps_2_0\n"
 939             "texkill t0\n",
 940             {0xffff0200, 0x01000041, 0xb00f0000, 0x0000ffff}
 941         },
 942         {   /* shader 7 */
 943             "ps_2_0\n"
 944             "mov oC0, c0\n"
 945             "mov oC1, c1\n",
 946             {0xffff0200, 0x02000001, 0x800f0800, 0xa0e40000, 0x02000001, 0x800f0801,
 947              0xa0e40001, 0x0000ffff}
 948         },
 949         {   /* shader 8 */
 950             "ps_2_0\n"
 951             "mov oDepth, c0.x\n",
 952             {0xffff0200, 0x02000001, 0x900f0800, 0xa0000000, 0x0000ffff}
 953         },
 954         {   /* shader 9 */
 955             "ps_2_0\n"
 956             "dcl_2d s2\n"
 957             "texldp r0, t1, s2\n",
 958             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03010042, 0x800f0000,
 959              0xb0e40001, 0xa0e40802, 0x0000ffff}
 960         },
 961         {   /* shader 10 */
 962             "ps_2_0\n"
 963             "dcl_2d s2\n"
 964             "texldb r0, t1, s2\n",
 965             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03020042, 0x800f0000,
 966              0xb0e40001, 0xa0e40802, 0x0000ffff}
 967         },
 968         {   /* shader 11 */
 969             "ps_2_0\n"
 970             "dcl v0\n",
 971             {0xffff0200, 0x0200001f, 0x80000000, 0x900f0000, 0x0000ffff}
 972         },
 973         {   /* shader 12 */
 974             "ps_2_0\n"
 975             "dcl t0.xyz\n"
 976             "dcl t1\n",
 977             {0xffff0200, 0x0200001f, 0x80000000, 0xb0070000, 0x0200001f, 0x80000000, 0xb00f0001, 0x0000ffff}
 978         },
 979         {   /* shader 13 */
 980             "ps_2_0\n"
 981             "dcl_pp t0\n",
 982             {0xffff0200, 0x0200001f, 0x80000000, 0xb02f0000, 0x0000ffff}
 983         },
 984     };
 985
 986     exec_tests("ps_2_0", tests, sizeof(tests) / sizeof(tests[0]));
 987 }
 988
 989 static void ps_2_x_test(void) {
 990     struct shader_test tests[] = {
 991         /* defb and defi are not supposed to work in ps_2_0 (even if defb actually works in ps_2_0 with native) */
 992         {   /* shader 0 */
 993             "ps_2_x\n"
 994             "defb b0, true\n"
 995             "defb b1, false\n",
 996             {0xffff0201, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
 997              0x00000000, 0x0000ffff}
 998         },
 999         {   /* shader 1 */
1000             "ps_2_x\n"
1001             "defi i0, -1, 1, 10, 0\n"
1002             "defi i1, 0, 40, 30, 10\n",
1003             {0xffff0201, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
1004              0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
1005              0x0000000a, 0x0000ffff}
1006         },
1007         {   /* shader 2 */
1008             "ps_2_x\n"
1009             "dsx r0, r0\n",
1010             {0xffff0201, 0x0200005b, 0x800f0000, 0x80e40000, 0x0000ffff}
1011         },
1012         {   /* shader 3 */
1013             "ps_2_x\n"
1014             "dsy r0, r0\n",
1015             {0xffff0201, 0x0200005c, 0x800f0000, 0x80e40000, 0x0000ffff}
1016         },
1017         {   /* shader 4 */
1018             "ps_2_x\n"
1019             "dcl_2d s2\n"
1020             "texldd r0, v1, s2, r3, r4\n",
1021             {0xffff0201, 0x0200001f, 0x90000000, 0xa00f0802, 0x0500005d, 0x800f0000,
1022              0x90e40001, 0xa0e40802, 0x80e40003, 0x80e40004, 0x0000ffff}
1023         },
1024         /* Static flow control tests */
1025         {   /* shader 5 */
1026             "ps_2_x\n"
1027             "call l0\n"
1028             "ret\n"
1029             "label l0\n"
1030             "ret\n",
1031             {0xffff0201, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
1032              0x0000001c, 0x0000ffff}
1033         },
1034         {   /* shader 6 */
1035             "ps_2_x\n"
1036             "callnz l0, b0\n"
1037             "ret\n"
1038             "label l0\n"
1039             "ret\n",
1040             {0xffff0201, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
1041              0xa0e41000, 0x0000001c, 0x0000ffff}
1042         },
1043         {   /* shader 7 */
1044             "ps_2_x\n"
1045             "callnz l0, !b0\n"
1046             "ret\n"
1047             "label l0\n"
1048             "ret\n",
1049             {0xffff0201, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
1050              0xa0e41000, 0x0000001c, 0x0000ffff}
1051         },
1052         {   /* shader 8 */
1053             "ps_2_x\n"
1054             "if !b0\n"
1055             "else\n"
1056             "endif\n",
1057             {0xffff0201, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
1058         },
1059         /* Dynamic flow control tests */
1060         {   /* shader 9 */
1061             "ps_2_x\n"
1062             "rep i0\n"
1063             "break\n"
1064             "endrep\n",
1065             {0xffff0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
1066         },
1067         {   /* shader 10 */
1068             "ps_2_x\n"
1069             "if_ge r0, r1\n"
1070             "endif\n",
1071             {0xffff0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
1072         },
1073         {   /* shader 11 */
1074             "ps_2_x\n"
1075             "rep i0\n"
1076             "break_ne r0, r1\n"
1077             "endrep",
1078             {0xffff0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
1079              0x00000027, 0x0000ffff}
1080         },
1081         /* Predicates */
1082         {   /* shader 12 */
1083             "ps_2_x\n"
1084             "setp_gt p0, r0, r1\n"
1085             "(!p0) add r2, r2, r3\n",
1086             {0xffff0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
1087              0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
1088         },
1089         {   /* shader 13 */
1090             "ps_2_x\n"
1091             "if p0.x\n"
1092             "else\n"
1093             "endif\n",
1094             {0xffff0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
1095         },
1096         {   /* shader 14 */
1097             "ps_2_x\n"
1098             "callnz l0, !p0.z\n"
1099             "ret\n"
1100             "label l0\n"
1101             "ret\n",
1102             {0xffff0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
1103              0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
1104         },
1105         {   /* shader 15 */
1106             "ps_2_x\n"
1107             "rep i0\n"
1108             "breakp p0.w\n"
1109             "endrep\n",
1110             {0xffff0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
1111              0x00000027, 0x0000ffff}
1112         },
1113         {   /* shader 16 */
1114             "ps_2_x\n"
1115             "call l2047\n"
1116             "ret\n"
1117             "label l2047\n"
1118             "ret\n",
1119             {0xffff0201, 0x01000019, 0xa0e417ff, 0x0000001c, 0x0100001e, 0xa0e417ff,
1120              0x0000001c, 0x0000ffff}
1121         },
1122     };
1123
1124     exec_tests("ps_2_x", tests, sizeof(tests) / sizeof(tests[0]));
1125 }
1126
1127 static void vs_3_0_test(void) {
1128     struct shader_test tests[] = {
1129         {   /* shader 0 */
1130             "vs_3_0\n"
1131             "mov r0, c0\n",
1132             {0xfffe0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1133         },
1134         {   /* shader 1 */
1135             "vs_3_0\n"
1136             "dcl_2d s0\n",
1137             {0xfffe0300, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
1138         },
1139         {   /* shader 2 */
1140             "vs_3_0\n"
1141             "dcl_position o0\n",
1142             {0xfffe0300, 0x0200001f, 0x80000000, 0xe00f0000, 0x0000ffff}
1143         },
1144         {   /* shader 3 */
1145             "vs_3_0\n"
1146             "dcl_texcoord12 o11\n",
1147             {0xfffe0300, 0x0200001f, 0x800c0005, 0xe00f000b, 0x0000ffff}
1148         },
1149         {   /* shader 4 */
1150             "vs_3_0\n"
1151             "texldl r0, v0, s0\n",
1152             {0xfffe0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1153         },
1154         {   /* shader 5 */
1155             "vs_3_0\n"
1156             "mov r0, c0[aL]\n",
1157             {0xfffe0300, 0x03000001, 0x800f0000, 0xa0e42000, 0xf0e40800, 0x0000ffff}
1158         },
1159         {   /* shader 6 */
1160             "vs_3_0\n"
1161             "mov o[ a0.x + 12 ], r0\n",
1162             {0xfffe0300, 0x03000001, 0xe00f200c, 0xb0000000, 0x80e40000, 0x0000ffff}
1163         },
1164         {   /* shader 7 */
1165             "vs_3_0\n"
1166             "add_sat r0, r0, r1\n",
1167             {0xfffe0300, 0x03000002, 0x801f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1168         },
1169         {   /* shader 8 */
1170             "vs_3_0\n"
1171             "mov r2, r1_abs\n",
1172             {0xfffe0300, 0x02000001, 0x800f0002, 0x8be40001, 0x0000ffff}
1173         },
1174         {   /* shader 9 */
1175             "vs_3_0\n"
1176             "mov r2, r1.xygb\n",
1177             {0xfffe0300, 0x02000001, 0x800f0002, 0x80940001, 0x0000ffff}
1178         },
1179         {   /* shader 10 */
1180             "vs_3_0\n"
1181             "mov r2.xyb, r1\n",
1182             {0xfffe0300, 0x02000001, 0x80070002, 0x80e40001, 0x0000ffff}
1183         },
1184         {   /* shader 11 */
1185             "vs_3_0\n"
1186             "mova_sat a0.x, r1\n",
1187             {0xfffe0300, 0x0200002e, 0xb0110000, 0x80e40001, 0x0000ffff}
1188         },
1189         {   /* shader 12 */
1190             "vs_3_0\n"
1191             "sincos r0, r1\n",
1192             {0xfffe0300, 0x02000025, 0x800f0000, 0x80e40001, 0x0000ffff}
1193         },
1194         {   /* shader 13 */
1195             "vs_3_0\n"
1196             "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
1197             {0xfffe0300, 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
1198              0x3f000000, 0x0000ffff}
1199         },
1200         {   /* shader 14: no register number checks with relative addressing */
1201             "vs_3_0\n"
1202             "add r0, v20[aL], r2\n",
1203             {0xfffe0300, 0x04000002, 0x800f0000, 0x90e42014, 0xf0e40800, 0x80e40002,
1204              0x0000ffff}
1205         },
1206
1207     };
1208
1209     exec_tests("vs_3_0", tests, sizeof(tests) / sizeof(tests[0]));
1210 }
1211
1212 static void ps_3_0_test(void) {
1213     struct shader_test tests[] = {
1214         {   /* shader 0 */
1215             "ps_3_0\n"
1216             "mov r0, c0\n",
1217             {0xffff0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1218         },
1219         {   /* shader 1 */
1220             "ps_3_0\n"
1221             "dcl_normal5 v0\n",
1222             {0xffff0300, 0x0200001f, 0x80050003, 0x900f0000, 0x0000ffff}
1223         },
1224         {   /* shader 2 */
1225             "ps_3_0\n"
1226             "mov r0, vPos\n",
1227             {0xffff0300, 0x02000001, 0x800f0000, 0x90e41000, 0x0000ffff}
1228         },
1229         {   /* shader 3 */
1230             "ps_3_0\n"
1231             "mov r0, vFace\n",
1232             {0xffff0300, 0x02000001, 0x800f0000, 0x90e41001, 0x0000ffff}
1233         },
1234         {   /* shader 4 */
1235             "ps_3_0\n"
1236             "mov r0, v[ aL + 12 ]\n",
1237             {0xffff0300, 0x03000001, 0x800f0000, 0x90e4200c, 0xf0e40800, 0x0000ffff}
1238         },
1239         {   /* shader 5 */
1240             "ps_3_0\n"
1241             "loop aL, i0\n"
1242             "mov r0, v0[aL]\n"
1243             "endloop\n",
1244             {0xffff0300, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
1245              0x90e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
1246         },
1247         {   /* shader 6 */
1248             "ps_3_0\n"
1249             "texldl r0, v0, s0\n",
1250             {0xffff0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1251         },
1252         {   /* shader 7 */
1253             "ps_3_0\n"
1254             "add_pp r0, r0, r1\n",
1255             {0xffff0300, 0x03000002, 0x802f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1256         },
1257         {   /* shader 8 */
1258             "ps_3_0\n"
1259             "dsx_sat r0, r1\n",
1260             {0xffff0300, 0x0200005b, 0x801f0000, 0x80e40001, 0x0000ffff}
1261         },
1262         {   /* shader 9 */
1263             "ps_3_0\n"
1264             "texldd_pp r0, r1, r2, r3, r4\n",
1265             {0xffff0300, 0x0500005d, 0x802f0000, 0x80e40001, 0x80e40002, 0x80e40003,
1266              0x80e40004, 0x0000ffff}
1267         },
1268         {   /* shader 10 */
1269             "ps_3_0\n"
1270             "texkill v0\n",
1271             {0xffff0300, 0x01000041, 0x900f0000, 0x0000ffff}
1272         },
1273         {   /* shader 11 */
1274             "ps_3_0\n"
1275             "add oC3, r0, r1\n",
1276             {0xffff0300, 0x03000002, 0x800f0803, 0x80e40000, 0x80e40001, 0x0000ffff}
1277         },
1278         {   /* shader 12 */
1279             "ps_3_0\n"
1280             "dcl_texcoord0_centroid v0\n",
1281             {0xffff0300, 0x0200001f, 0x80000005, 0x904f0000, 0x0000ffff}
1282         },
1283         {   /* shader 13 */
1284             "ps_3_0\n"
1285             "dcl_2d_centroid s0\n",
1286             {0xffff0300, 0x0200001f, 0x90000000, 0xa04f0800, 0x0000ffff}
1287         },
1288         {   /* shader 14 */
1289             "ps_3_0\n"
1290             "dcl_2d_pp s0\n",
1291             {0xffff0300, 0x0200001f, 0x90000000, 0xa02f0800, 0x0000ffff}
1292         },
1293         {   /* shader 15 */
1294             "ps_3_0\n"
1295             "dcl v0\n",
1296             {0xffff0300, 0x0200001f, 0x80000000, 0x900f0000, 0x0000ffff}
1297         },
1298         {   /* shader 16 */
1299             "ps_3_0\n"
1300             "dcl s2\n",
1301             {0xffff0300, 0x0200001f, 0x80000000, 0xa00f0802, 0x0000ffff}
1302         },
1303     };
1304
1305     exec_tests("ps_3_0", tests, sizeof(tests) / sizeof(tests[0]));
1306 }
1307
1308 static void failure_test(void) {
1309     const char * tests[] = {
1310         /* shader 0: instruction modifier not allowed */
1311         "ps_3_0\n"
1312         "dcl_2d s2\n"
1313         "texldd_x2 r0, v1, s2, v3, v4\n",
1314         /* shader 1: coissue not supported in vertex shaders */
1315         "vs.1.1\r\n"
1316         "add r0.rgb, r0, r1\n"
1317         "+add r0.a, r0, r2\n",
1318         /* shader 2: coissue not supported in pixel shader version >= 2.0 */
1319         "ps_2_0\n"
1320         "texld r0, t0, s0\n"
1321         "add r0.rgb, r0, r1\n"
1322         "+add r0.a, r0, v1\n",
1323         /* shader 3: predicates not supported in vertex shader < 2.0 */
1324         "vs_1_1\n"
1325         "(p0) add r0, r0, v0\n",
1326         /* shader 4: register a0 doesn't exist in pixel shaders */
1327         "ps_3_0\n"
1328         "mov r0, v[ a0 + 12 ]\n",
1329         /* shader 5: s0 doesn't exist in vs_1_1 */
1330         "vs_1_1\n"
1331         "mov r0, s0\n",
1332         /* shader 6: aL is a scalar register, no swizzles allowed */
1333         "ps_3_0\n"
1334         "mov r0, v[ aL.x + 12 ]\n",
1335         /* shader 7: tn doesn't exist in ps_3_0 */
1336         "ps_3_0\n"
1337         "dcl_2d s2\n"
1338         "texldd r0, t1, s2, v3, v4\n",
1339         /* shader 8: two shift modifiers */
1340         "ps_1_3\n"
1341         "mov_x2_x2 r0, r1\n",
1342         /* shader 9: too many source registers for mov instruction */
1343         "vs_1_1\n"
1344         "mov r0, r1, r2\n",
1345         /* shader 10: invalid combination of negate and divide modifiers */
1346         "ps_1_4\n"
1347         "texld r5, -r2_dz\n",
1348         /* shader 11: complement modifier not allowed in >= PS 2 */
1349         "ps_2_0\n"
1350         "mov r2, 1 - r0\n",
1351         /* shader 12: invalid modifier */
1352         "vs_3_0\n"
1353         "mov r2, 2 - r0\n",
1354         /* shader 13: float value in relative addressing */
1355         "vs_3_0\n"
1356         "mov r2, c[ aL + 3.4 ]\n",
1357         /* shader 14: complement modifier not available in VS */
1358         "vs_3_0\n"
1359         "mov r2, 1 - r1\n",
1360         /* shader 15: _x2 modifier not available in VS */
1361         "vs_1_1\n"
1362         "mov r2, r1_x2\n",
1363         /* shader 16: _abs modifier not available in < VS 3.0 */
1364         "vs_1_1\n"
1365         "mov r2, r1_abs\n",
1366         /* shader 17: _x2 modifier not available in >= PS 2.0 */
1367         "ps_2_0\n"
1368         "mov r0, r1_x2\n",
1369         /* shader 18: wrong swizzle */
1370         "vs_2_0\n"
1371         "mov r0, r1.abcd\n",
1372         /* shader 19: wrong swizzle */
1373         "vs_2_0\n"
1374         "mov r0, r1.xyzwx\n",
1375         /* shader 20: wrong swizzle */
1376         "vs_2_0\n"
1377         "mov r0, r1.\n",
1378         /* shader 21: invalid writemask */
1379         "vs_2_0\n"
1380         "mov r0.xxyz, r1\n",
1381         /* shader 22: register r5 doesn't exist in PS < 1.4 */
1382         "ps_1_3\n"
1383         "mov r5, r0\n",
1384         /* shader 23: can't declare output registers in a pixel shader */
1385         "ps_3_0\n"
1386         "dcl_positiont o0\n",
1387         /* shader 24: _pp instruction modifier not allowed in vertex shaders */
1388         "vs_3_0\n"
1389         "add_pp r0, r0, r1\n",
1390         /* shader 25: _x4 instruction modified not allowed in > ps_1_x */
1391         "ps_3_0\n"
1392         "add_x4 r0, r0, r1\n",
1393         /* shader 26: there aren't oCx registers in ps_1_x */
1394         "ps_1_3\n"
1395         "add oC0, r0, r1\n",
1396         /* shader 27: oC3 is the max in >= ps_2_0 */
1397         "ps_3_0\n"
1398         "add oC4, r0, r1\n",
1399         /* shader 28: register v17 doesn't exist */
1400         "vs_3_0\n"
1401         "add r0, r0, v17\n",
1402         /* shader 29: register o13 doesn't exist */
1403         "vs_3_0\n"
1404         "add o13, r0, r1\n",
1405         /* shader 30: label > 2047 not allowed */
1406         "vs_3_0\n"
1407         "call l2048\n",
1408         /* shader 31: s20 register does not exist */
1409         "ps_3_0\n"
1410         "texld r0, r1, s20\n",
1411         /* shader 32: t5 not allowed in ps_1_3 */
1412         "ps_1_3\n"
1413         "tex t5\n",
1414         /* shader 33: no temporary registers relative addressing */
1415         "vs_3_0\n"
1416         "add r0, r0[ a0.x ], r1\n",
1417         /* shader 34: no input registers relative addressing in vs_2_0 */
1418         "vs_2_0\n"
1419         "add r0, v[ a0.x ], r1\n",
1420         /* shader 35: no aL register in ps_2_0 */
1421         "ps_2_0\n"
1422         "add r0, v[ aL ], r1\n",
1423         /* shader 36: no relative addressing in ps_2_0 */
1424         "ps_2_0\n"
1425         "add r0, v[ r0 ], r1\n",
1426         /* shader 37: no a0 register in ps_3_0 */
1427         "ps_3_0\n"
1428         "add r0, v[ a0.x ], r1\n",
1429         /* shader 38: only a0.x accepted in vs_1_1 */
1430         "vs_1_1\n"
1431         "mov r0, c0[ a0 ]\n",
1432         /* shader 39: invalid modifier for dcl instruction */
1433         "ps_3_0\n"
1434         "dcl_texcoord0_sat v0\n",
1435         /* shader 40: shift not allowed */
1436         "ps_3_0\n"
1437         "dcl_texcoord0_x2 v0\n",
1438         /* shader 41: no modifier allowed with dcl instruction in vs */
1439         "vs_3_0\n"
1440         "dcl_texcoord0_centroid v0\n",
1441         /* shader 42: no modifiers with vs dcl sampler instruction */
1442         "vs_3_0\n"
1443         "dcl_2d_pp s0\n",
1444         /* shader 43: can't explicitly declare input registers in ps_2_0 */
1445         "ps_2_0\n"
1446         "dcl_texcoord0 t0\n",
1447         /* shader 44: can't implicitly declare registers in vs */
1448         "vs_2_0\n"
1449         "dcl o0\n",
1450         /* shader 45: can't implicitly declare samplers in vs */
1451         "vs_3_0\n"
1452         "dcl s2\n",
1453         /* shader 46: no tx registers in ps_3_0 */
1454         "ps_3_0\n"
1455         "dcl t2\n",
1456         /* shader 47: no samplers in vs_2_0 */
1457         "vs_2_0\n"
1458         "dcl_2d s2\n",
1459         /* shader 48: semantic required in vs dcl input instruction */
1460         "vs_2_0\n"
1461         "dcl v0\n",
1462         /* shader 49: semantic not allowed in ps dcl input instruction*/
1463         "ps_2_0\n"
1464         "dcl_position0 v0\n",
1465         /* shader 50: dcl instruction not in ps_1_x */
1466         "ps_1_4\n"
1467         "dcl_position0 v0\n",
1468         /* shader 51: no dcl output instruction in < vs 3.0 */
1469         "vs_2_0\n"
1470         "dcl_positiont0 o0\n",
1471     };
1472     HRESULT hr;
1473     unsigned int i;
1474     LPD3DXBUFFER shader,messages;
1475
1476     for(i = 0; i < (sizeof(tests) / sizeof(tests[0])); i++) {
1477         shader = NULL;
1478         messages = NULL;
1479         hr = D3DXAssembleShader(tests[i], strlen(tests[i]),
1480                                 NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1481                                 &shader, &messages);
1482         ok(hr == D3DXERR_INVALIDDATA, "Failure test, shader %d: "
1483            "expected D3DXAssembleShader failure with D3DXERR_INVALIDDATA, "
1484            "got 0x%x - %d\n", i, hr, hr & 0x0000FFFF);
1485         if(messages) {
1486             trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1487             ID3DXBuffer_Release(messages);
1488         }
1489         if(shader) {
1490             DWORD *res = ID3DXBuffer_GetBufferPointer(shader);
1491             dump_shader(res);
1492             ID3DXBuffer_Release(shader);
1493         }
1494     }
1495 }
1496
1497
1498 static HRESULT WINAPI testD3DXInclude_open(ID3DXInclude *iface,
1499                                            D3DXINCLUDE_TYPE include_type,
1500                                            LPCSTR filename, LPCVOID parent_data,
1501                                            LPCVOID *data, UINT *bytes) {
1502     char *buffer;
1503     const char include[] = "#define REGISTER r0\nvs.1.1\n";
1504     const char include2[] = "#include \"incl3.vsh\"\n";
1505     const char include3[] = "vs.1.1\n";
1506
1507     trace("filename = %s\n", filename);
1508     trace("parent_data = (%p) -> %s\n", parent_data, (char *)parent_data);
1509
1510     if(!strcmp(filename,"incl.vsh")) {
1511         buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include));
1512         CopyMemory(buffer, include, sizeof(include));
1513         *bytes = sizeof(include);
1514         /* Also check for the correct parent_data content */
1515         ok(parent_data == NULL, "wrong parent_data value\n");
1516     }
1517     else if(!strcmp(filename,"incl3.vsh")) {
1518         buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include3));
1519         CopyMemory(buffer, include3, sizeof(include3));
1520         *bytes = sizeof(include3);
1521         /* Also check for the correct parent_data content */
1522         ok(parent_data != NULL && !strncmp(include2, parent_data, strlen(include2)), "wrong parent_data value\n");
1523     }
1524     else {
1525         buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include2));
1526         CopyMemory(buffer, include2, sizeof(include2));
1527         *bytes = sizeof(include2);
1528     }
1529     *data = buffer;
1530     return S_OK;
1531 }
1532
1533 static HRESULT WINAPI testD3DXInclude_close(ID3DXInclude *iface, LPCVOID data) {
1534     HeapFree(GetProcessHeap(), 0, (LPVOID)data);
1535     return S_OK;
1536 }
1537
1538 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl = {
1539     testD3DXInclude_open,
1540     testD3DXInclude_close
1541 };
1542
1543 struct D3DXIncludeImpl {
1544     const ID3DXIncludeVtbl *lpVtbl;
1545 };
1546
1547 static void assembleshader_test(void) {
1548     const char test1[] = {
1549         "vs.1.1\n"
1550         "mov DEF2, v0\n"
1551     };
1552     const char testincl[] = {
1553         "#define REGISTER r0\n"
1554         "vs.1.1\n"
1555     };
1556     const char testshader[] = {
1557         "#include \"incl.vsh\"\n"
1558         "mov REGISTER, v0\n"
1559     };
1560     const char testshader2[] = {
1561         "#include \"incl2.vsh\"\n"
1562         "mov REGISTER, v0\n"
1563     };
1564     const char testshader3[] = {
1565         "#include \"include/incl3.vsh\"\n"
1566         "mov REGISTER, v0\n"
1567     };
1568     const char testincl3[] = {
1569         "#include \"incl4.vsh\"\n"
1570     };
1571     const char testincl4_ok[] = {
1572         "vs.1.1\n"
1573     };
1574     const char testincl4_wrong[] = {
1575         "#error \"wrong include\"\n"
1576     };
1577     HRESULT hr;
1578     LPD3DXBUFFER shader, messages;
1579     D3DXMACRO defines[] = {
1580         {
1581             "DEF1", "10 + 15"
1582         },
1583         {
1584             "DEF2", "r0"
1585         },
1586         {
1587             NULL, NULL
1588         }
1589     };
1590     struct D3DXIncludeImpl include;
1591     HRESULT shader_vsh_res;
1592
1593     /* pDefines test */
1594     shader = NULL;
1595     messages = NULL;
1596     hr = D3DXAssembleShader(test1, strlen(test1),
1597                             defines, NULL, D3DXSHADER_SKIPVALIDATION,
1598                             &shader, &messages);
1599     ok(hr == D3D_OK, "pDefines test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1600     if(messages) {
1601         trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1602         ID3DXBuffer_Release(messages);
1603     }
1604     if(shader) ID3DXBuffer_Release(shader);
1605
1606     /* NULL messages test */
1607     shader = NULL;
1608     hr = D3DXAssembleShader(test1, strlen(test1),
1609                             defines, NULL, D3DXSHADER_SKIPVALIDATION,
1610                             &shader, NULL);
1611     ok(hr == D3D_OK, "NULL messages test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1612     if(shader) ID3DXBuffer_Release(shader);
1613
1614     /* NULL shader test */
1615     messages = NULL;
1616     hr = D3DXAssembleShader(test1, strlen(test1),
1617                             defines, NULL, D3DXSHADER_SKIPVALIDATION,
1618                             NULL, &messages);
1619     ok(hr == D3D_OK, "NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1620     if(messages) {
1621         trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1622         ID3DXBuffer_Release(messages);
1623     }
1624
1625     /* pInclude test */
1626     shader = NULL;
1627     messages = NULL;
1628     include.lpVtbl = &D3DXInclude_Vtbl;
1629     hr = D3DXAssembleShader(testshader, strlen(testshader),
1630                             NULL, (LPD3DXINCLUDE)&include, D3DXSHADER_SKIPVALIDATION,
1631                             &shader, &messages);
1632     ok(hr == D3D_OK, "pInclude test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1633     if(messages) {
1634         trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1635         ID3DXBuffer_Release(messages);
1636     }
1637     if(shader) ID3DXBuffer_Release(shader);
1638
1639     /* "unexpected #include file from memory" test */
1640     shader = NULL;
1641     messages = NULL;
1642     hr = D3DXAssembleShader(testshader, strlen(testshader),
1643                             NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1644                             &shader, &messages);
1645     ok(hr == D3DXERR_INVALIDDATA, "D3DXAssembleShader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1646     if(messages) {
1647         trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1648         ID3DXBuffer_Release(messages);
1649     }
1650     if(shader) ID3DXBuffer_Release(shader);
1651
1652     /* recursive #include test */
1653     shader = NULL;
1654     messages = NULL;
1655     hr = D3DXAssembleShader(testshader2, strlen(testshader2),
1656                             NULL, (LPD3DXINCLUDE)&include, D3DXSHADER_SKIPVALIDATION,
1657                             &shader, &messages);
1658     ok(hr == D3D_OK, "D3DXAssembleShader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1659     if(messages) {
1660         trace("recursive D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1661         ID3DXBuffer_Release(messages);
1662     }
1663     if(shader) ID3DXBuffer_Release(shader);
1664
1665     shader_vsh_res = create_file("shader.vsh", testshader, sizeof(testshader));
1666     if(SUCCEEDED(shader_vsh_res)) {
1667         create_file("incl.vsh", testincl, sizeof(testincl));
1668
1669         /* D3DXAssembleShaderFromFile + #include test */
1670         shader = NULL;
1671         messages = NULL;
1672         hr = D3DXAssembleShaderFromFileA("shader.vsh",
1673                                          NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1674                                          &shader, &messages);
1675         ok(hr == D3D_OK, "D3DXAssembleShaderFromFile test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1676         if(messages) {
1677             trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1678             ID3DXBuffer_Release(messages);
1679         }
1680         if(shader) ID3DXBuffer_Release(shader);
1681
1682         /* D3DXAssembleShaderFromFile + pInclude test */
1683         shader = NULL;
1684         messages = NULL;
1685         hr = D3DXAssembleShaderFromFileA("shader.vsh",
1686                                          NULL, (LPD3DXINCLUDE)&include, D3DXSHADER_SKIPVALIDATION,
1687                                          &shader, &messages);
1688         ok(hr == D3D_OK, "D3DXAssembleShaderFromFile + pInclude test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1689         if(messages) {
1690             trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1691             ID3DXBuffer_Release(messages);
1692         }
1693         if(shader) ID3DXBuffer_Release(shader);
1694
1695         create_file("shader3.vsh", testshader3, sizeof(testshader3));
1696         create_file("incl4.vsh", testincl4_wrong, sizeof(testincl4_wrong));
1697         if(CreateDirectoryA("include", NULL)) {
1698             create_file("include/incl3.vsh", testincl3, sizeof(testincl3));
1699             create_file("include/incl4.vsh", testincl4_ok, sizeof(testincl4_ok));
1700
1701             /* path search #include test */
1702             shader = NULL;
1703             messages = NULL;
1704             hr = D3DXAssembleShaderFromFileA("shader3.vsh", NULL, NULL,
1705                                              D3DXSHADER_SKIPVALIDATION,
1706                                              &shader, &messages);
1707             ok(hr == D3D_OK, "D3DXAssembleShaderFromFile path search test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1708             if(messages) {
1709                 trace("D3DXAssembleShaderFromFile path search messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1710                 ID3DXBuffer_Release(messages);
1711             }
1712             if(shader) ID3DXBuffer_Release(shader);
1713         } else skip("Couldn't create \"include\" directory\n");
1714     } else skip("Couldn't create \"shader.vsh\"\n");
1715
1716     /* NULL shader tests */
1717     shader = NULL;
1718     messages = NULL;
1719     hr = D3DXAssembleShader(NULL, 0,
1720                             NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1721                             &shader, &messages);
1722     ok(hr == D3DXERR_INVALIDDATA, "NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1723     if(messages) {
1724         trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1725         ID3DXBuffer_Release(messages);
1726     }
1727     if(shader) ID3DXBuffer_Release(shader);
1728
1729     shader = NULL;
1730     messages = NULL;
1731     hr = D3DXAssembleShaderFromFileA("nonexistent.vsh",
1732                                      NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1733                                      &shader, &messages);
1734     ok(hr == D3DXERR_INVALIDDATA || hr == E_FAIL, /* I get this on WinXP */
1735         "D3DXAssembleShaderFromFile nonexistent file test failed with error 0x%x - %d\n",
1736         hr, hr & 0x0000FFFF);
1737     if(messages) {
1738         trace("D3DXAssembleShaderFromFile messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1739         ID3DXBuffer_Release(messages);
1740     }
1741     if(shader) ID3DXBuffer_Release(shader);
1742
1743     /* D3DXAssembleShaderFromResource test */
1744     shader = NULL;
1745     messages = NULL;
1746     hr = D3DXAssembleShaderFromResourceA(NULL, MAKEINTRESOURCEA(IDB_ASMSHADER),
1747                                          NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1748                                          &shader, &messages);
1749     ok(hr == D3D_OK, "D3DXAssembleShaderFromResource test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1750     if(messages) {
1751         trace("D3DXAssembleShaderFromResource messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1752         ID3DXBuffer_Release(messages);
1753     }
1754     if(shader) ID3DXBuffer_Release(shader);
1755
1756     /* D3DXAssembleShaderFromResource with missing shader resource test */
1757     shader = NULL;
1758     messages = NULL;
1759     hr = D3DXAssembleShaderFromResourceA(NULL, "notexisting",
1760                                          NULL, NULL, D3DXSHADER_SKIPVALIDATION,
1761                                          &shader, &messages);
1762     ok(hr == D3DXERR_INVALIDDATA, "D3DXAssembleShaderFromResource NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1763     if(messages) {
1764         trace("D3DXAssembleShaderFromResource messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
1765         ID3DXBuffer_Release(messages);
1766     }
1767     if(shader) ID3DXBuffer_Release(shader);
1768
1769     /* cleanup */
1770     if(SUCCEEDED(shader_vsh_res)) {
1771         DeleteFileA("shader.vsh");
1772         DeleteFileA("incl.vsh");
1773         DeleteFileA("shader3.vsh");
1774         DeleteFileA("incl4.vsh");
1775         DeleteFileA("include/incl3.vsh");
1776         DeleteFileA("include/incl4.vsh");
1777         RemoveDirectoryA("include");
1778     }
1779 }
1780
1781 START_TEST(asm)
1782 {
1783     preproc_test();
1784     ps_1_1_test();
1785     vs_1_1_test();
1786     ps_1_3_test();
1787     ps_1_4_test();
1788     vs_2_0_test();
1789     vs_2_x_test();
1790     ps_2_0_test();
1791     ps_2_x_test();
1792     vs_3_0_test();
1793     ps_3_0_test();
1794
1795     failure_test();
1796
1797     assembleshader_test();
1798 }