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