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, DWORD count) 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 */ 1234