[D3DCOMPILER_43] Fix a MSVC-x64 warning about dxbc_init() (#1173)
[reactos.git] / dll / directx / wine / d3dcompiler_43 / d3dcompiler_private.h
1 /*
2 * Copyright 2008 Stefan Dösinger
3 * Copyright 2009 Matteo Bruni
4 * Copyright 2010 Rico Schüller
5 * Copyright 2012 Matteo Bruni for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #ifndef __WINE_D3DCOMPILER_PRIVATE_H
23 #define __WINE_D3DCOMPILER_PRIVATE_H
24
25 #include "wine/debug.h"
26 #include "wine/list.h"
27 #include "wine/rbtree.h"
28
29 #define COBJMACROS
30 #include "windef.h"
31 #include "winbase.h"
32 #include "objbase.h"
33
34 #include "d3dcompiler.h"
35
36 #include <assert.h>
37
38 /*
39 * This doesn't belong here, but for some functions it is possible to return that value,
40 * see http://msdn.microsoft.com/en-us/library/bb205278%28v=VS.85%29.aspx
41 * The original definition is in D3DX10core.h.
42 */
43 #define D3DERR_INVALIDCALL 0x8876086c
44
45 /* TRACE helper functions */
46 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part) DECLSPEC_HIDDEN;
47 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c) DECLSPEC_HIDDEN;
48 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t) DECLSPEC_HIDDEN;
49
50 enum shader_type
51 {
52 ST_UNKNOWN,
53 ST_VERTEX,
54 ST_PIXEL
55 };
56
57 enum bwriter_comparison_type
58 {
59 BWRITER_COMPARISON_NONE,
60 BWRITER_COMPARISON_GT,
61 BWRITER_COMPARISON_EQ,
62 BWRITER_COMPARISON_GE,
63 BWRITER_COMPARISON_LT,
64 BWRITER_COMPARISON_NE,
65 BWRITER_COMPARISON_LE
66 };
67
68 struct constant {
69 DWORD regnum;
70 union {
71 float f;
72 INT i;
73 BOOL b;
74 DWORD d;
75 } value[4];
76 };
77
78 struct shader_reg {
79 DWORD type;
80 DWORD regnum;
81 struct shader_reg *rel_reg;
82 DWORD srcmod;
83 union {
84 DWORD swizzle;
85 DWORD writemask;
86 } u;
87 };
88
89 struct instruction {
90 DWORD opcode;
91 DWORD dstmod;
92 DWORD shift;
93 enum bwriter_comparison_type comptype;
94 BOOL has_dst;
95 struct shader_reg dst;
96 struct shader_reg *src;
97 unsigned int num_srcs; /* For freeing the rel_regs */
98 BOOL has_predicate;
99 struct shader_reg predicate;
100 BOOL coissue;
101 };
102
103 struct declaration {
104 DWORD usage, usage_idx;
105 DWORD regnum;
106 DWORD mod;
107 DWORD writemask;
108 BOOL builtin;
109 };
110
111 struct samplerdecl {
112 DWORD type;
113 DWORD regnum;
114 DWORD mod;
115 };
116
117 #define INSTRARRAY_INITIAL_SIZE 8
118 struct bwriter_shader {
119 enum shader_type type;
120
121 /* Shader version selected */
122 DWORD version;
123
124 /* Local constants. Every constant that is not defined below is loaded from
125 * the global constant set at shader runtime
126 */
127 struct constant **constF;
128 struct constant **constI;
129 struct constant **constB;
130 unsigned int num_cf, num_ci, num_cb;
131
132 /* Declared input and output varyings */
133 struct declaration *inputs, *outputs;
134 unsigned int num_inputs, num_outputs;
135 struct samplerdecl *samplers;
136 unsigned int num_samplers;
137
138 /* Are special pixel shader 3.0 registers declared? */
139 BOOL vPos, vFace;
140
141 /* Array of shader instructions - The shader code itself */
142 struct instruction **instr;
143 unsigned int num_instrs, instr_alloc_size;
144 };
145
146 static inline void *d3dcompiler_alloc(SIZE_T size)
147 {
148 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
149 }
150
151 static inline void *d3dcompiler_realloc(void *ptr, SIZE_T size)
152 {
153 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
154 }
155
156 static inline BOOL d3dcompiler_free(void *ptr)
157 {
158 return HeapFree(GetProcessHeap(), 0, ptr);
159 }
160
161 static inline char *d3dcompiler_strdup(const char *string)
162 {
163 char *copy;
164 SIZE_T len;
165
166 if (!string)
167 return NULL;
168
169 len = strlen(string);
170 copy = d3dcompiler_alloc(len + 1);
171 if (copy)
172 memcpy(copy, string, len + 1);
173 return copy;
174 }
175
176 struct asm_parser;
177
178 /* This structure is only used in asmshader.y, but since the .l file accesses the semantic types
179 * too it has to know it as well
180 */
181 struct rel_reg {
182 BOOL has_rel_reg;
183 DWORD type;
184 DWORD additional_offset;
185 DWORD rel_regnum;
186 DWORD swizzle;
187 };
188
189 #define MAX_SRC_REGS 4
190
191 struct src_regs {
192 struct shader_reg reg[MAX_SRC_REGS];
193 unsigned int count;
194 };
195
196 struct asmparser_backend {
197 void (*constF)(struct asm_parser *This, DWORD reg, float x, float y, float z, float w);
198 void (*constI)(struct asm_parser *This, DWORD reg, INT x, INT y, INT z, INT w);
199 void (*constB)(struct asm_parser *This, DWORD reg, BOOL x);
200
201 void (*dstreg)(struct asm_parser *This, struct instruction *instr,
202 const struct shader_reg *dst);
203 void (*srcreg)(struct asm_parser *This, struct instruction *instr, int num,
204 const struct shader_reg *src);
205
206 void (*predicate)(struct asm_parser *This,
207 const struct shader_reg *predicate);
208 void (*coissue)(struct asm_parser *This);
209
210 void (*dcl_output)(struct asm_parser *This, DWORD usage, DWORD num,
211 const struct shader_reg *reg);
212 void (*dcl_input)(struct asm_parser *This, DWORD usage, DWORD num,
213 DWORD mod, const struct shader_reg *reg);
214 void (*dcl_sampler)(struct asm_parser *This, DWORD samptype, DWORD mod,
215 DWORD regnum, unsigned int line_no);
216
217 void (*end)(struct asm_parser *This);
218
219 void (*instr)(struct asm_parser *parser, DWORD opcode, DWORD mod, DWORD shift,
220 enum bwriter_comparison_type comp, const struct shader_reg *dst,
221 const struct src_regs *srcs, int expectednsrcs);
222 };
223
224 struct instruction *alloc_instr(unsigned int srcs) DECLSPEC_HIDDEN;
225 BOOL add_instruction(struct bwriter_shader *shader, struct instruction *instr) DECLSPEC_HIDDEN;
226 BOOL add_constF(struct bwriter_shader *shader, DWORD reg, float x, float y, float z, float w) DECLSPEC_HIDDEN;
227 BOOL add_constI(struct bwriter_shader *shader, DWORD reg, INT x, INT y, INT z, INT w) DECLSPEC_HIDDEN;
228 BOOL add_constB(struct bwriter_shader *shader, DWORD reg, BOOL x) DECLSPEC_HIDDEN;
229 BOOL record_declaration(struct bwriter_shader *shader, DWORD usage, DWORD usage_idx,
230 DWORD mod, BOOL output, DWORD regnum, DWORD writemask, BOOL builtin) DECLSPEC_HIDDEN;
231 BOOL record_sampler(struct bwriter_shader *shader, DWORD samptype, DWORD mod, DWORD regnum) DECLSPEC_HIDDEN;
232
233 #define MESSAGEBUFFER_INITIAL_SIZE 256
234
235 enum parse_status
236 {
237 PARSE_SUCCESS = 0,
238 PARSE_WARN = 1,
239 PARSE_ERR = 2
240 };
241
242 struct compilation_messages
243 {
244 char *string;
245 unsigned int size;
246 unsigned int capacity;
247 };
248
249 struct asm_parser
250 {
251 /* The function table of the parser implementation */
252 const struct asmparser_backend *funcs;
253
254 /* Private data follows */
255 struct bwriter_shader *shader;
256 unsigned int m3x3pad_count;
257
258 enum parse_status status;
259 struct compilation_messages messages;
260 unsigned int line_no;
261 };
262
263 extern struct asm_parser asm_ctx DECLSPEC_HIDDEN;
264
265 void create_vs10_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
266 void create_vs11_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
267 void create_vs20_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
268 void create_vs2x_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
269 void create_vs30_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
270 void create_ps10_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
271 void create_ps11_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
272 void create_ps12_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
273 void create_ps13_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
274 void create_ps14_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
275 void create_ps20_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
276 void create_ps2x_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
277 void create_ps30_parser(struct asm_parser *ret) DECLSPEC_HIDDEN;
278
279 struct bwriter_shader *parse_asm_shader(char **messages) DECLSPEC_HIDDEN;
280
281 #ifdef __GNUC__
282 #define PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args)))
283 #else
284 #define PRINTF_ATTR(fmt,args)
285 #endif
286
287 void compilation_message(struct compilation_messages *msg, const char *fmt, va_list args) DECLSPEC_HIDDEN;
288 void asmparser_message(struct asm_parser *ctx, const char *fmt, ...) PRINTF_ATTR(2,3) DECLSPEC_HIDDEN;
289 static inline void set_parse_status(enum parse_status *current, enum parse_status update)
290 {
291 if (update == PARSE_ERR)
292 *current = PARSE_ERR;
293 else if (update == PARSE_WARN && *current == PARSE_SUCCESS)
294 *current = PARSE_WARN;
295 }
296
297 /* A reasonable value as initial size */
298 #define BYTECODEBUFFER_INITIAL_SIZE 32
299 struct bytecode_buffer {
300 DWORD *data;
301 DWORD size;
302 DWORD alloc_size;
303 /* For tracking rare out of memory situations without passing
304 * return values around everywhere
305 */
306 HRESULT state;
307 };
308
309 struct bc_writer; /* Predeclaration for use in vtable parameters */
310
311 typedef void (*instr_writer)(struct bc_writer *This,
312 const struct instruction *instr,
313 struct bytecode_buffer *buffer);
314
315 struct bytecode_backend {
316 void (*header)(struct bc_writer *This, const struct bwriter_shader *shader,
317 struct bytecode_buffer *buffer);
318 void (*end)(struct bc_writer *This, const struct bwriter_shader *shader,
319 struct bytecode_buffer *buffer);
320 void (*srcreg)(struct bc_writer *This, const struct shader_reg *reg,
321 struct bytecode_buffer *buffer);
322 void (*dstreg)(struct bc_writer *This, const struct shader_reg *reg,
323 struct bytecode_buffer *buffer, DWORD shift, DWORD mod);
324 void (*opcode)(struct bc_writer *This, const struct instruction *instr,
325 DWORD token, struct bytecode_buffer *buffer);
326
327 const struct instr_handler_table {
328 DWORD opcode;
329 instr_writer func;
330 } *instructions;
331 };
332
333 /* Bytecode writing stuff */
334 struct bc_writer {
335 const struct bytecode_backend *funcs;
336
337 /* Avoid result checking */
338 HRESULT state;
339
340 DWORD version;
341
342 /* Vertex shader varying mapping */
343 DWORD oPos_regnum;
344 DWORD oD_regnum[2];
345 DWORD oT_regnum[8];
346 DWORD oFog_regnum;
347 DWORD oFog_mask;
348 DWORD oPts_regnum;
349 DWORD oPts_mask;
350
351 /* Pixel shader specific members */
352 DWORD t_regnum[8];
353 DWORD v_regnum[2];
354 };
355
356 /* Debug utility routines */
357 const char *debug_print_srcmod(DWORD mod) DECLSPEC_HIDDEN;
358 const char *debug_print_dstmod(DWORD mod) DECLSPEC_HIDDEN;
359 const char *debug_print_shift(DWORD shift) DECLSPEC_HIDDEN;
360 const char *debug_print_dstreg(const struct shader_reg *reg) DECLSPEC_HIDDEN;
361 const char *debug_print_srcreg(const struct shader_reg *reg) DECLSPEC_HIDDEN;
362 const char *debug_print_comp(DWORD comp) DECLSPEC_HIDDEN;
363 const char *debug_print_opcode(DWORD opcode) DECLSPEC_HIDDEN;
364
365 /* Used to signal an incorrect swizzle/writemask */
366 #define SWIZZLE_ERR ~0U
367
368 /* Enumerations and defines used in the bytecode writer intermediate
369 * representation. */
370 enum bwritershader_instruction_opcode_type
371 {
372 BWRITERSIO_NOP,
373 BWRITERSIO_MOV,
374 BWRITERSIO_ADD,
375 BWRITERSIO_SUB,
376 BWRITERSIO_MAD,
377 BWRITERSIO_MUL,
378 BWRITERSIO_RCP,
379 BWRITERSIO_RSQ,
380 BWRITERSIO_DP3,
381 BWRITERSIO_DP4,
382 BWRITERSIO_MIN,
383 BWRITERSIO_MAX,
384 BWRITERSIO_SLT,
385 BWRITERSIO_SGE,
386 BWRITERSIO_EXP,
387 BWRITERSIO_LOG,
388 BWRITERSIO_LIT,
389 BWRITERSIO_DST,
390 BWRITERSIO_LRP,
391 BWRITERSIO_FRC,
392 BWRITERSIO_M4x4,
393 BWRITERSIO_M4x3,
394 BWRITERSIO_M3x4,
395 BWRITERSIO_M3x3,
396 BWRITERSIO_M3x2,
397 BWRITERSIO_CALL,
398 BWRITERSIO_CALLNZ,
399 BWRITERSIO_LOOP,
400 BWRITERSIO_RET,
401 BWRITERSIO_ENDLOOP,
402 BWRITERSIO_LABEL,
403 BWRITERSIO_DCL,
404 BWRITERSIO_POW,
405 BWRITERSIO_CRS,
406 BWRITERSIO_SGN,
407 BWRITERSIO_ABS,
408 BWRITERSIO_NRM,
409 BWRITERSIO_SINCOS,
410 BWRITERSIO_REP,
411 BWRITERSIO_ENDREP,
412 BWRITERSIO_IF,
413 BWRITERSIO_IFC,
414 BWRITERSIO_ELSE,
415 BWRITERSIO_ENDIF,
416 BWRITERSIO_BREAK,
417 BWRITERSIO_BREAKC,
418 BWRITERSIO_MOVA,
419 BWRITERSIO_DEFB,
420 BWRITERSIO_DEFI,
421
422 BWRITERSIO_TEXCOORD,
423 BWRITERSIO_TEXKILL,
424 BWRITERSIO_TEX,
425 BWRITERSIO_TEXBEM,
426 BWRITERSIO_TEXBEML,
427 BWRITERSIO_TEXREG2AR,
428 BWRITERSIO_TEXREG2GB,
429 BWRITERSIO_TEXM3x2PAD,
430 BWRITERSIO_TEXM3x2TEX,
431 BWRITERSIO_TEXM3x3PAD,
432 BWRITERSIO_TEXM3x3TEX,
433 BWRITERSIO_TEXM3x3SPEC,
434 BWRITERSIO_TEXM3x3VSPEC,
435 BWRITERSIO_EXPP,
436 BWRITERSIO_LOGP,
437 BWRITERSIO_CND,
438 BWRITERSIO_DEF,
439 BWRITERSIO_TEXREG2RGB,
440 BWRITERSIO_TEXDP3TEX,
441 BWRITERSIO_TEXM3x2DEPTH,
442 BWRITERSIO_TEXDP3,
443 BWRITERSIO_TEXM3x3,
444 BWRITERSIO_TEXDEPTH,
445 BWRITERSIO_CMP,
446 BWRITERSIO_BEM,
447 BWRITERSIO_DP2ADD,
448 BWRITERSIO_DSX,
449 BWRITERSIO_DSY,
450 BWRITERSIO_TEXLDD,
451 BWRITERSIO_SETP,
452 BWRITERSIO_TEXLDL,
453 BWRITERSIO_BREAKP,
454 BWRITERSIO_TEXLDP,
455 BWRITERSIO_TEXLDB,
456
457 BWRITERSIO_PHASE,
458 BWRITERSIO_COMMENT,
459 BWRITERSIO_END,
460 };
461
462 enum bwritershader_param_register_type
463 {
464 BWRITERSPR_TEMP,
465 BWRITERSPR_INPUT,
466 BWRITERSPR_CONST,
467 BWRITERSPR_ADDR,
468 BWRITERSPR_TEXTURE,
469 BWRITERSPR_RASTOUT,
470 BWRITERSPR_ATTROUT,
471 BWRITERSPR_TEXCRDOUT,
472 BWRITERSPR_OUTPUT,
473 BWRITERSPR_CONSTINT,
474 BWRITERSPR_COLOROUT,
475 BWRITERSPR_DEPTHOUT,
476 BWRITERSPR_SAMPLER,
477 BWRITERSPR_CONSTBOOL,
478 BWRITERSPR_LOOP,
479 BWRITERSPR_MISCTYPE,
480 BWRITERSPR_LABEL,
481 BWRITERSPR_PREDICATE
482 };
483
484 enum bwritervs_rastout_offsets
485 {
486 BWRITERSRO_POSITION,
487 BWRITERSRO_FOG,
488 BWRITERSRO_POINT_SIZE
489 };
490
491 #define BWRITERSP_WRITEMASK_0 0x1 /* .x r */
492 #define BWRITERSP_WRITEMASK_1 0x2 /* .y g */
493 #define BWRITERSP_WRITEMASK_2 0x4 /* .z b */
494 #define BWRITERSP_WRITEMASK_3 0x8 /* .w a */
495 #define BWRITERSP_WRITEMASK_ALL 0xf /* all */
496
497 enum bwritershader_param_dstmod_type
498 {
499 BWRITERSPDM_NONE = 0,
500 BWRITERSPDM_SATURATE = 1,
501 BWRITERSPDM_PARTIALPRECISION = 2,
502 BWRITERSPDM_MSAMPCENTROID = 4,
503 };
504
505 enum bwritersampler_texture_type
506 {
507 BWRITERSTT_UNKNOWN = 0,
508 BWRITERSTT_1D = 1,
509 BWRITERSTT_2D = 2,
510 BWRITERSTT_CUBE = 3,
511 BWRITERSTT_VOLUME = 4,
512 };
513
514 #define BWRITERSI_TEXLD_PROJECT 1
515 #define BWRITERSI_TEXLD_BIAS 2
516
517 enum bwritershader_param_srcmod_type
518 {
519 BWRITERSPSM_NONE = 0,
520 BWRITERSPSM_NEG,
521 BWRITERSPSM_BIAS,
522 BWRITERSPSM_BIASNEG,
523 BWRITERSPSM_SIGN,
524 BWRITERSPSM_SIGNNEG,
525 BWRITERSPSM_COMP,
526 BWRITERSPSM_X2,
527 BWRITERSPSM_X2NEG,
528 BWRITERSPSM_DZ,
529 BWRITERSPSM_DW,
530 BWRITERSPSM_ABS,
531 BWRITERSPSM_ABSNEG,
532 BWRITERSPSM_NOT,
533 };
534
535 #define BWRITER_SM1_VS 0xfffeu
536 #define BWRITER_SM1_PS 0xffffu
537
538 #define BWRITERPS_VERSION(major, minor) ((BWRITER_SM1_PS << 16) | ((major) << 8) | (minor))
539 #define BWRITERVS_VERSION(major, minor) ((BWRITER_SM1_VS << 16) | ((major) << 8) | (minor))
540
541 #define BWRITERVS_SWIZZLE_SHIFT 16
542 #define BWRITERVS_SWIZZLE_MASK (0xFF << BWRITERVS_SWIZZLE_SHIFT)
543
544 #define BWRITERVS_X_X (0 << BWRITERVS_SWIZZLE_SHIFT)
545 #define BWRITERVS_X_Y (1 << BWRITERVS_SWIZZLE_SHIFT)
546 #define BWRITERVS_X_Z (2 << BWRITERVS_SWIZZLE_SHIFT)
547 #define BWRITERVS_X_W (3 << BWRITERVS_SWIZZLE_SHIFT)
548
549 #define BWRITERVS_Y_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 2))
550 #define BWRITERVS_Y_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 2))
551 #define BWRITERVS_Y_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 2))
552 #define BWRITERVS_Y_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 2))
553
554 #define BWRITERVS_Z_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 4))
555 #define BWRITERVS_Z_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 4))
556 #define BWRITERVS_Z_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 4))
557 #define BWRITERVS_Z_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 4))
558
559 #define BWRITERVS_W_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 6))
560 #define BWRITERVS_W_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 6))
561 #define BWRITERVS_W_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 6))
562 #define BWRITERVS_W_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 6))
563
564 #define BWRITERVS_NOSWIZZLE (BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z | BWRITERVS_W_W)
565
566 #define BWRITERVS_SWIZZLE_X (BWRITERVS_X_X | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X)
567 #define BWRITERVS_SWIZZLE_Y (BWRITERVS_X_Y | BWRITERVS_Y_Y | BWRITERVS_Z_Y | BWRITERVS_W_Y)
568 #define BWRITERVS_SWIZZLE_Z (BWRITERVS_X_Z | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z)
569 #define BWRITERVS_SWIZZLE_W (BWRITERVS_X_W | BWRITERVS_Y_W | BWRITERVS_Z_W | BWRITERVS_W_W)
570
571 enum bwriterdeclusage
572 {
573 BWRITERDECLUSAGE_POSITION,
574 BWRITERDECLUSAGE_BLENDWEIGHT,
575 BWRITERDECLUSAGE_BLENDINDICES,
576 BWRITERDECLUSAGE_NORMAL,
577 BWRITERDECLUSAGE_PSIZE,
578 BWRITERDECLUSAGE_TEXCOORD,
579 BWRITERDECLUSAGE_TANGENT,
580 BWRITERDECLUSAGE_BINORMAL,
581 BWRITERDECLUSAGE_TESSFACTOR,
582 BWRITERDECLUSAGE_POSITIONT,
583 BWRITERDECLUSAGE_COLOR,
584 BWRITERDECLUSAGE_FOG,
585 BWRITERDECLUSAGE_DEPTH,
586 BWRITERDECLUSAGE_SAMPLE
587 };
588
589 /* ps 1.x texture registers mappings */
590 #define T0_REG 2
591 #define T1_REG 3
592 #define T2_REG 4
593 #define T3_REG 5
594
595 struct bwriter_shader *SlAssembleShader(const char *text, char **messages) DECLSPEC_HIDDEN;
596 HRESULT SlWriteBytecode(const struct bwriter_shader *shader, int dxversion, DWORD **result, DWORD *size) DECLSPEC_HIDDEN;
597 void SlDeleteShader(struct bwriter_shader *shader) DECLSPEC_HIDDEN;
598
599 /* The general IR structure is inspired by Mesa GLSL hir, even though the code
600 * ends up being quite different in practice. Anyway, here comes the relevant
601 * licensing information.
602 *
603 * Copyright © 2010 Intel Corporation
604 *
605 * Permission is hereby granted, free of charge, to any person obtaining a
606 * copy of this software and associated documentation files (the "Software"),
607 * to deal in the Software without restriction, including without limitation
608 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
609 * and/or sell copies of the Software, and to permit persons to whom the
610 * Software is furnished to do so, subject to the following conditions:
611 *
612 * The above copyright notice and this permission notice (including the next
613 * paragraph) shall be included in all copies or substantial portions of the
614 * Software.
615 *
616 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
617 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
618 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
619 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
620 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
621 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
622 * DEALINGS IN THE SOFTWARE.
623 */
624
625 enum hlsl_type_class
626 {
627 HLSL_CLASS_SCALAR,
628 HLSL_CLASS_VECTOR,
629 HLSL_CLASS_MATRIX,
630 HLSL_CLASS_LAST_NUMERIC = HLSL_CLASS_MATRIX,
631 HLSL_CLASS_STRUCT,
632 HLSL_CLASS_ARRAY,
633 HLSL_CLASS_OBJECT,
634 };
635
636 enum hlsl_base_type
637 {
638 HLSL_TYPE_FLOAT,
639 HLSL_TYPE_HALF,
640 HLSL_TYPE_DOUBLE,
641 HLSL_TYPE_INT,
642 HLSL_TYPE_UINT,
643 HLSL_TYPE_BOOL,
644 HLSL_TYPE_LAST_SCALAR = HLSL_TYPE_BOOL,
645 HLSL_TYPE_SAMPLER,
646 HLSL_TYPE_TEXTURE,
647 HLSL_TYPE_PIXELSHADER,
648 HLSL_TYPE_VERTEXSHADER,
649 HLSL_TYPE_STRING,
650 HLSL_TYPE_VOID,
651 };
652
653 enum hlsl_sampler_dim
654 {
655 HLSL_SAMPLER_DIM_GENERIC,
656 HLSL_SAMPLER_DIM_1D,
657 HLSL_SAMPLER_DIM_2D,
658 HLSL_SAMPLER_DIM_3D,
659 HLSL_SAMPLER_DIM_CUBE,
660 };
661
662 enum hlsl_matrix_majority
663 {
664 HLSL_COLUMN_MAJOR,
665 HLSL_ROW_MAJOR
666 };
667
668 struct hlsl_type
669 {
670 struct list entry;
671 struct wine_rb_entry scope_entry;
672 enum hlsl_type_class type;
673 enum hlsl_base_type base_type;
674 enum hlsl_sampler_dim sampler_dim;
675 const char *name;
676 unsigned int modifiers;
677 unsigned int dimx;
678 unsigned int dimy;
679 union
680 {
681 struct list *elements;
682 struct
683 {
684 struct hlsl_type *type;
685 unsigned int elements_count;
686 } array;
687 } e;
688 };
689
690 struct hlsl_struct_field
691 {
692 struct list entry;
693 struct hlsl_type *type;
694 const char *name;
695 const char *semantic;
696 DWORD modifiers;
697 };
698
699 struct source_location
700 {
701 const char *file;
702 unsigned int line;
703 unsigned int col;
704 };
705
706 enum hlsl_ir_node_type
707 {
708 HLSL_IR_VAR = 0,
709 HLSL_IR_ASSIGNMENT,
710 HLSL_IR_CONSTANT,
711 HLSL_IR_CONSTRUCTOR,
712 HLSL_IR_DEREF,
713 HLSL_IR_EXPR,
714 HLSL_IR_FUNCTION_DECL,
715 HLSL_IR_IF,
716 HLSL_IR_LOOP,
717 HLSL_IR_JUMP,
718 HLSL_IR_SWIZZLE,
719 };
720
721 struct hlsl_ir_node
722 {
723 struct list entry;
724 enum hlsl_ir_node_type type;
725 struct hlsl_type *data_type;
726
727 struct source_location loc;
728 };
729
730 #define HLSL_STORAGE_EXTERN 0x00000001
731 #define HLSL_STORAGE_NOINTERPOLATION 0x00000002
732 #define HLSL_MODIFIER_PRECISE 0x00000004
733 #define HLSL_STORAGE_SHARED 0x00000008
734 #define HLSL_STORAGE_GROUPSHARED 0x00000010
735 #define HLSL_STORAGE_STATIC 0x00000020
736 #define HLSL_STORAGE_UNIFORM 0x00000040
737 #define HLSL_STORAGE_VOLATILE 0x00000080
738 #define HLSL_MODIFIER_CONST 0x00000100
739 #define HLSL_MODIFIER_ROW_MAJOR 0x00000200
740 #define HLSL_MODIFIER_COLUMN_MAJOR 0x00000400
741 #define HLSL_MODIFIER_IN 0x00000800
742 #define HLSL_MODIFIER_OUT 0x00001000
743
744 #define HLSL_TYPE_MODIFIERS_MASK (HLSL_MODIFIER_PRECISE | HLSL_STORAGE_VOLATILE | \
745 HLSL_MODIFIER_CONST | HLSL_MODIFIER_ROW_MAJOR | \
746 HLSL_MODIFIER_COLUMN_MAJOR)
747
748 #define HLSL_MODIFIERS_COMPARISON_MASK (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)
749
750 struct reg_reservation
751 {
752 enum bwritershader_param_register_type type;
753 DWORD regnum;
754 };
755
756 struct hlsl_ir_var
757 {
758 struct hlsl_ir_node node;
759 const char *name;
760 const char *semantic;
761 unsigned int modifiers;
762 const struct reg_reservation *reg_reservation;
763 struct list scope_entry;
764
765 struct hlsl_var_allocation *allocation;
766 };
767
768 struct hlsl_ir_function
769 {
770 struct wine_rb_entry entry;
771 const char *name;
772 struct wine_rb_tree overloads;
773 BOOL intrinsic;
774 };
775
776 struct hlsl_ir_function_decl
777 {
778 struct hlsl_ir_node node;
779 struct wine_rb_entry entry;
780 struct hlsl_ir_function *func;
781 const char *semantic;
782 struct list *parameters;
783 struct list *body;
784 };
785
786 struct hlsl_ir_if
787 {
788 struct hlsl_ir_node node;
789 struct hlsl_ir_node *condition;
790 struct list *then_instrs;
791 struct list *else_instrs;
792 };
793
794 struct hlsl_ir_loop
795 {
796 struct hlsl_ir_node node;
797 /* loop condition is stored in the body (as "if (!condition) break;") */
798 struct list *body;
799 };
800
801 struct hlsl_ir_assignment
802 {
803 struct hlsl_ir_node node;
804 struct hlsl_ir_node *lhs;
805 struct hlsl_ir_node *rhs;
806 unsigned char writemask;
807 };
808
809 enum hlsl_ir_expr_op {
810 HLSL_IR_UNOP_BIT_NOT = 0,
811 HLSL_IR_UNOP_LOGIC_NOT,
812 HLSL_IR_UNOP_NEG,
813 HLSL_IR_UNOP_ABS,
814 HLSL_IR_UNOP_SIGN,
815 HLSL_IR_UNOP_RCP,
816 HLSL_IR_UNOP_RSQ,
817 HLSL_IR_UNOP_SQRT,
818 HLSL_IR_UNOP_NRM,
819 HLSL_IR_UNOP_EXP2,
820 HLSL_IR_UNOP_LOG2,
821
822 HLSL_IR_UNOP_CAST,
823
824 HLSL_IR_UNOP_FRACT,
825
826 HLSL_IR_UNOP_SIN,
827 HLSL_IR_UNOP_COS,
828 HLSL_IR_UNOP_SIN_REDUCED, /* Reduced range [-pi, pi] */
829 HLSL_IR_UNOP_COS_REDUCED, /* Reduced range [-pi, pi] */
830
831 HLSL_IR_UNOP_DSX,
832 HLSL_IR_UNOP_DSY,
833
834 HLSL_IR_UNOP_SAT,
835
836 HLSL_IR_UNOP_PREINC,
837 HLSL_IR_UNOP_PREDEC,
838 HLSL_IR_UNOP_POSTINC,
839 HLSL_IR_UNOP_POSTDEC,
840
841 HLSL_IR_BINOP_ADD,
842 HLSL_IR_BINOP_SUB,
843 HLSL_IR_BINOP_MUL,
844 HLSL_IR_BINOP_DIV,
845
846 HLSL_IR_BINOP_MOD,
847
848 HLSL_IR_BINOP_LESS,
849 HLSL_IR_BINOP_GREATER,
850 HLSL_IR_BINOP_LEQUAL,
851 HLSL_IR_BINOP_GEQUAL,
852 HLSL_IR_BINOP_EQUAL,
853 HLSL_IR_BINOP_NEQUAL,
854
855 HLSL_IR_BINOP_LOGIC_AND,
856 HLSL_IR_BINOP_LOGIC_OR,
857
858 HLSL_IR_BINOP_LSHIFT,
859 HLSL_IR_BINOP_RSHIFT,
860 HLSL_IR_BINOP_BIT_AND,
861 HLSL_IR_BINOP_BIT_OR,
862 HLSL_IR_BINOP_BIT_XOR,
863
864 HLSL_IR_BINOP_DOT,
865 HLSL_IR_BINOP_CRS,
866 HLSL_IR_BINOP_MIN,
867 HLSL_IR_BINOP_MAX,
868
869 HLSL_IR_BINOP_POW,
870
871 HLSL_IR_TEROP_LERP,
872
873 HLSL_IR_SEQUENCE,
874 };
875
876 struct hlsl_ir_expr
877 {
878 struct hlsl_ir_node node;
879 enum hlsl_ir_expr_op op;
880 struct hlsl_ir_node *operands[3];
881 struct list *subexpressions;
882 };
883
884 enum hlsl_ir_jump_type
885 {
886 HLSL_IR_JUMP_BREAK,
887 HLSL_IR_JUMP_CONTINUE,
888 HLSL_IR_JUMP_DISCARD,
889 HLSL_IR_JUMP_RETURN,
890 };
891
892 struct hlsl_ir_jump
893 {
894 struct hlsl_ir_node node;
895 enum hlsl_ir_jump_type type;
896 struct hlsl_ir_node *return_value;
897 };
898
899 struct hlsl_ir_swizzle
900 {
901 struct hlsl_ir_node node;
902 struct hlsl_ir_node *val;
903 DWORD swizzle;
904 };
905
906 enum hlsl_ir_deref_type
907 {
908 HLSL_IR_DEREF_VAR,
909 HLSL_IR_DEREF_ARRAY,
910 HLSL_IR_DEREF_RECORD,
911 };
912
913 struct hlsl_ir_deref
914 {
915 struct hlsl_ir_node node;
916 enum hlsl_ir_deref_type type;
917 union
918 {
919 struct hlsl_ir_var *var;
920 struct
921 {
922 struct hlsl_ir_node *array;
923 struct hlsl_ir_node *index;
924 } array;
925 struct
926 {
927 struct hlsl_ir_node *record;
928 struct hlsl_struct_field *field;
929 } record;
930 } v;
931 };
932
933 struct hlsl_ir_constant
934 {
935 struct hlsl_ir_node node;
936 union
937 {
938 union
939 {
940 unsigned u[16];
941 int i[16];
942 float f[16];
943 double d[16];
944 BOOL b[16];
945 } value;
946 struct hlsl_ir_constant *array_elements;
947 struct list *struct_elements;
948 } v;
949 };
950
951 struct hlsl_ir_constructor
952 {
953 struct hlsl_ir_node node;
954 struct list *arguments;
955 };
956
957 struct hlsl_scope
958 {
959 struct list entry;
960 struct list vars;
961 struct wine_rb_tree types;
962 struct hlsl_scope *upper;
963 };
964
965 /* Structures used only during parsing */
966 struct parse_parameter
967 {
968 struct hlsl_type *type;
969 const char *name;
970 const char *semantic;
971 const struct reg_reservation *reg_reservation;
972 unsigned int modifiers;
973 };
974
975 struct parse_colon_attribute
976 {
977 const char *semantic;
978 struct reg_reservation *reg_reservation;
979 };
980
981 struct parse_variable_def
982 {
983 struct list entry;
984 struct source_location loc;
985
986 char *name;
987 unsigned int array_size;
988 const char *semantic;
989 struct reg_reservation *reg_reservation;
990 struct list *initializer;
991 };
992
993 struct parse_function
994 {
995 char *name;
996 struct hlsl_ir_function_decl *decl;
997 };
998
999 struct parse_if_body
1000 {
1001 struct list *then_instrs;
1002 struct list *else_instrs;
1003 };
1004
1005 enum parse_unary_op
1006 {
1007 UNARY_OP_PLUS,
1008 UNARY_OP_MINUS,
1009 UNARY_OP_LOGICNOT,
1010 UNARY_OP_BITNOT,
1011 };
1012
1013 enum parse_assign_op
1014 {
1015 ASSIGN_OP_ASSIGN,
1016 ASSIGN_OP_ADD,
1017 ASSIGN_OP_SUB,
1018 ASSIGN_OP_MUL,
1019 ASSIGN_OP_DIV,
1020 ASSIGN_OP_MOD,
1021 ASSIGN_OP_LSHIFT,
1022 ASSIGN_OP_RSHIFT,
1023 ASSIGN_OP_AND,
1024 ASSIGN_OP_OR,
1025 ASSIGN_OP_XOR,
1026 };
1027
1028 struct hlsl_parse_ctx
1029 {
1030 const char **source_files;
1031 unsigned int source_files_count;
1032 const char *source_file;
1033 unsigned int line_no;
1034 unsigned int column;
1035 enum parse_status status;
1036 struct compilation_messages messages;
1037
1038 struct hlsl_scope *cur_scope;
1039 struct hlsl_scope *globals;
1040 struct list scopes;
1041
1042 struct list types;
1043 struct wine_rb_tree functions;
1044
1045 enum hlsl_matrix_majority matrix_majority;
1046 };
1047
1048 extern struct hlsl_parse_ctx hlsl_ctx DECLSPEC_HIDDEN;
1049
1050 enum hlsl_error_level
1051 {
1052 HLSL_LEVEL_ERROR = 0,
1053 HLSL_LEVEL_WARNING,
1054 HLSL_LEVEL_NOTE,
1055 };
1056
1057 void hlsl_message(const char *fmt, ...) PRINTF_ATTR(1,2) DECLSPEC_HIDDEN;
1058 void hlsl_report_message(const char *filename, DWORD line, DWORD column,
1059 enum hlsl_error_level level, const char *fmt, ...) PRINTF_ATTR(5,6) DECLSPEC_HIDDEN;
1060
1061 static inline struct hlsl_ir_var *var_from_node(const struct hlsl_ir_node *node)
1062 {
1063 assert(node->type == HLSL_IR_VAR);
1064 return CONTAINING_RECORD(node, struct hlsl_ir_var, node);
1065 }
1066
1067 static inline struct hlsl_ir_expr *expr_from_node(const struct hlsl_ir_node *node)
1068 {
1069 assert(node->type == HLSL_IR_EXPR);
1070 return CONTAINING_RECORD(node, struct hlsl_ir_expr, node);
1071 }
1072
1073 static inline struct hlsl_ir_deref *deref_from_node(const struct hlsl_ir_node *node)
1074 {
1075 assert(node->type == HLSL_IR_DEREF);
1076 return CONTAINING_RECORD(node, struct hlsl_ir_deref, node);
1077 }
1078
1079 static inline struct hlsl_ir_constant *constant_from_node(const struct hlsl_ir_node *node)
1080 {
1081 assert(node->type == HLSL_IR_CONSTANT);
1082 return CONTAINING_RECORD(node, struct hlsl_ir_constant, node);
1083 }
1084
1085 static inline struct hlsl_ir_jump *jump_from_node(const struct hlsl_ir_node *node)
1086 {
1087 assert(node->type == HLSL_IR_JUMP);
1088 return CONTAINING_RECORD(node, struct hlsl_ir_jump, node);
1089 }
1090
1091 static inline struct hlsl_ir_assignment *assignment_from_node(const struct hlsl_ir_node *node)
1092 {
1093 assert(node->type == HLSL_IR_ASSIGNMENT);
1094 return CONTAINING_RECORD(node, struct hlsl_ir_assignment, node);
1095 }
1096
1097 static inline struct hlsl_ir_swizzle *swizzle_from_node(const struct hlsl_ir_node *node)
1098 {
1099 assert(node->type == HLSL_IR_SWIZZLE);
1100 return CONTAINING_RECORD(node, struct hlsl_ir_swizzle, node);
1101 }
1102
1103 static inline struct hlsl_ir_constructor *constructor_from_node(const struct hlsl_ir_node *node)
1104 {
1105 assert(node->type == HLSL_IR_CONSTRUCTOR);
1106 return CONTAINING_RECORD(node, struct hlsl_ir_constructor, node);
1107 }
1108
1109 static inline struct hlsl_ir_if *if_from_node(const struct hlsl_ir_node *node)
1110 {
1111 assert(node->type == HLSL_IR_IF);
1112 return CONTAINING_RECORD(node, struct hlsl_ir_if, node);
1113 }
1114
1115 static inline struct hlsl_ir_loop *loop_from_node(const struct hlsl_ir_node *node)
1116 {
1117 assert(node->type == HLSL_IR_LOOP);
1118 return CONTAINING_RECORD(node, struct hlsl_ir_loop, node);
1119 }
1120
1121 BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var) DECLSPEC_HIDDEN;
1122 struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name) DECLSPEC_HIDDEN;
1123 void free_declaration(struct hlsl_ir_var *decl) DECLSPEC_HIDDEN;
1124 struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_type_class type_class,
1125 enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) DECLSPEC_HIDDEN;
1126 struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size) DECLSPEC_HIDDEN;
1127 struct hlsl_type *clone_hlsl_type(struct hlsl_type *old) DECLSPEC_HIDDEN;
1128 struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN;
1129 BOOL find_function(const char *name) DECLSPEC_HIDDEN;
1130 unsigned int components_count_type(struct hlsl_type *type) DECLSPEC_HIDDEN;
1131 BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2) DECLSPEC_HIDDEN;
1132 BOOL compatible_data_types(struct hlsl_type *s1, struct hlsl_type *s2) DECLSPEC_HIDDEN;
1133 struct hlsl_ir_expr *new_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node **operands,
1134 struct source_location *loc) DECLSPEC_HIDDEN;
1135 struct hlsl_ir_expr *new_cast(struct hlsl_ir_node *node, struct hlsl_type *type,
1136 struct source_location *loc) DECLSPEC_HIDDEN;
1137 struct hlsl_ir_expr *hlsl_mul(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1138 struct source_location *loc) DECLSPEC_HIDDEN;
1139 struct hlsl_ir_expr *hlsl_div(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1140 struct source_location *loc) DECLSPEC_HIDDEN;
1141 struct hlsl_ir_expr *hlsl_mod(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1142 struct source_location *loc) DECLSPEC_HIDDEN;
1143 struct hlsl_ir_expr *hlsl_add(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1144 struct source_location *loc) DECLSPEC_HIDDEN;
1145 struct hlsl_ir_expr *hlsl_sub(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1146 struct source_location *loc) DECLSPEC_HIDDEN;
1147 struct hlsl_ir_expr *hlsl_lt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1148 struct source_location *loc) DECLSPEC_HIDDEN;
1149 struct hlsl_ir_expr *hlsl_gt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1150 struct source_location *loc) DECLSPEC_HIDDEN;
1151 struct hlsl_ir_expr *hlsl_le(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1152 struct source_location *loc) DECLSPEC_HIDDEN;
1153 struct hlsl_ir_expr *hlsl_ge(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1154 struct source_location *loc) DECLSPEC_HIDDEN;
1155 struct hlsl_ir_expr *hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1156 struct source_location *loc) DECLSPEC_HIDDEN;
1157 struct hlsl_ir_expr *hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1158 struct source_location *loc) DECLSPEC_HIDDEN;
1159 struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var) DECLSPEC_HIDDEN;
1160 struct hlsl_ir_deref *new_record_deref(struct hlsl_ir_node *record, struct hlsl_struct_field *field) DECLSPEC_HIDDEN;
1161 struct hlsl_ir_node *make_assignment(struct hlsl_ir_node *left, enum parse_assign_op assign_op,
1162 DWORD writemask, struct hlsl_ir_node *right) DECLSPEC_HIDDEN;
1163 void push_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN;
1164 BOOL pop_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN;
1165 struct hlsl_ir_function_decl *new_func_decl(struct hlsl_type *return_type, struct list *parameters) DECLSPEC_HIDDEN;
1166 void init_functions_tree(struct wine_rb_tree *funcs) DECLSPEC_HIDDEN;
1167 void add_function_decl(struct wine_rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl,
1168 BOOL intrinsic) DECLSPEC_HIDDEN;
1169 struct bwriter_shader *parse_hlsl_shader(const char *text, enum shader_type type, DWORD major, DWORD minor,
1170 const char *entrypoint, char **messages) DECLSPEC_HIDDEN;
1171
1172 const char *debug_hlsl_type(const struct hlsl_type *type) DECLSPEC_HIDDEN;
1173 const char *debug_modifiers(DWORD modifiers) DECLSPEC_HIDDEN;
1174 void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl *func) DECLSPEC_HIDDEN;
1175
1176 void free_hlsl_type(struct hlsl_type *type) DECLSPEC_HIDDEN;
1177 void free_instr(struct hlsl_ir_node *node) DECLSPEC_HIDDEN;
1178 void free_instr_list(struct list *list) DECLSPEC_HIDDEN;
1179 void free_function_rb(struct wine_rb_entry *entry, void *context) DECLSPEC_HIDDEN;
1180
1181
1182 #define MAKE_TAG(ch0, ch1, ch2, ch3) \
1183 ((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \
1184 ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))
1185 #define TAG_Aon9 MAKE_TAG('A', 'o', 'n', '9')
1186 #define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C')
1187 #define TAG_ISGN MAKE_TAG('I', 'S', 'G', 'N')
1188 #define TAG_OSGN MAKE_TAG('O', 'S', 'G', 'N')
1189 #define TAG_OSG5 MAKE_TAG('O', 'S', 'G', '5')
1190 #define TAG_PCSG MAKE_TAG('P', 'C', 'S', 'G')
1191 #define TAG_RDEF MAKE_TAG('R', 'D', 'E', 'F')
1192 #define TAG_SDBG MAKE_TAG('S', 'D', 'B', 'G')
1193 #define TAG_SHDR MAKE_TAG('S', 'H', 'D', 'R')
1194 #define TAG_SHEX MAKE_TAG('S', 'H', 'E', 'X')
1195 #define TAG_STAT MAKE_TAG('S', 'T', 'A', 'T')
1196 #define TAG_XNAP MAKE_TAG('X', 'N', 'A', 'P')
1197 #define TAG_XNAS MAKE_TAG('X', 'N', 'A', 'S')
1198
1199 struct dxbc_section
1200 {
1201 DWORD tag;
1202 const char *data;
1203 DWORD data_size;
1204 };
1205
1206 struct dxbc
1207 {
1208 UINT size;
1209 UINT count;
1210 struct dxbc_section *sections;
1211 };
1212
1213 HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob) DECLSPEC_HIDDEN;
1214 void dxbc_destroy(struct dxbc *dxbc) DECLSPEC_HIDDEN;
1215 HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) DECLSPEC_HIDDEN;
1216 HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size) DECLSPEC_HIDDEN;
1217 HRESULT dxbc_init(struct dxbc *dxbc, unsigned int size) DECLSPEC_HIDDEN;
1218
1219 static inline void read_dword(const char **ptr, DWORD *d)
1220 {
1221 memcpy(d, *ptr, sizeof(*d));
1222 *ptr += sizeof(*d);
1223 }
1224
1225 static inline void write_dword(char **ptr, DWORD d)
1226 {
1227 memcpy(*ptr, &d, sizeof(d));
1228 *ptr += sizeof(d);
1229 }
1230
1231 void skip_dword_unknown(const char **ptr, unsigned int count) DECLSPEC_HIDDEN;
1232
1233 #endif /* __WINE_D3DCOMPILER_PRIVATE_H */