ReactOS  0.4.14-dev-98-gb0d4763
utils.c
Go to the documentation of this file.
1 /*
2  * Copyright 2008 Stefan Dösinger
3  * Copyright 2009 Matteo Bruni
4  * Copyright 2008-2009 Henri Verbeet for CodeWeavers
5  * Copyright 2010 Rico Schüller
6  * Copyright 2012 Matteo Bruni for CodeWeavers
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  *
22  */
23 
24 #include "config.h"
25 #include "wine/port.h"
26 
27 #include <stdio.h>
28 
29 #include "d3dcompiler_private.h"
30 
31 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
32 
33 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
34 
36 {
37  switch (c)
38  {
47  default:
48  FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
49  return "unrecognized";
50  }
51 }
52 
54 {
55  switch (t)
56  {
103  default:
104  FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
105  return "unrecognized";
106  }
107 }
108 
110 {
111  switch(part)
112  {
125  default:
126  FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
127  return "unrecognized";
128  }
129 }
130 
132 {
133  switch (mod)
134  {
148  default:
149  FIXME("Unrecognized source modifier %#x.\n", mod);
150  return "unrecognized_src_mod";
151  }
152 }
153 
154 #undef WINE_D3DCOMPILER_TO_STR
155 
157 {
158  switch (mod)
159  {
160  case 0:
161  return "";
163  return "_sat";
165  return "_pp";
167  return "_centroid";
169  return "_sat_pp";
171  return "_sat_centroid";
173  return "_pp_centroid";
175  return "_sat_pp_centroid";
176  default:
177  return "Unexpected modifier\n";
178  }
179 }
180 
182 {
183  static const char * const shiftstrings[] =
184  {
185  "",
186  "_x2",
187  "_x4",
188  "_x8",
189  "_x16",
190  "_x32",
191  "",
192  "",
193  "",
194  "",
195  "",
196  "",
197  "_d16",
198  "_d8",
199  "_d4",
200  "_d2",
201  };
202  return shiftstrings[shift];
203 }
204 
205 static const char *get_regname(const struct shader_reg *reg)
206 {
207  switch (reg->type)
208  {
209  case BWRITERSPR_TEMP:
210  return wine_dbg_sprintf("r%u", reg->regnum);
211  case BWRITERSPR_INPUT:
212  return wine_dbg_sprintf("v%u", reg->regnum);
213  case BWRITERSPR_CONST:
214  return wine_dbg_sprintf("c%u", reg->regnum);
215  case BWRITERSPR_ADDR:
216  return wine_dbg_sprintf("a%u", reg->regnum);
217  case BWRITERSPR_TEXTURE:
218  return wine_dbg_sprintf("t%u", reg->regnum);
219  case BWRITERSPR_RASTOUT:
220  switch (reg->regnum)
221  {
222  case BWRITERSRO_POSITION: return "oPos";
223  case BWRITERSRO_FOG: return "oFog";
224  case BWRITERSRO_POINT_SIZE: return "oPts";
225  default: return "Unexpected RASTOUT";
226  }
227  case BWRITERSPR_ATTROUT:
228  return wine_dbg_sprintf("oD%u", reg->regnum);
230  return wine_dbg_sprintf("oT%u", reg->regnum);
231  case BWRITERSPR_OUTPUT:
232  return wine_dbg_sprintf("o%u", reg->regnum);
233  case BWRITERSPR_CONSTINT:
234  return wine_dbg_sprintf("i%u", reg->regnum);
235  case BWRITERSPR_COLOROUT:
236  return wine_dbg_sprintf("oC%u", reg->regnum);
237  case BWRITERSPR_DEPTHOUT:
238  return "oDepth";
239  case BWRITERSPR_SAMPLER:
240  return wine_dbg_sprintf("s%u", reg->regnum);
242  return wine_dbg_sprintf("b%u", reg->regnum);
243  case BWRITERSPR_LOOP:
244  return "aL";
245  case BWRITERSPR_MISCTYPE:
246  switch (reg->regnum)
247  {
248  case 0: return "vPos";
249  case 1: return "vFace";
250  default: return "unexpected misctype";
251  }
252  case BWRITERSPR_LABEL:
253  return wine_dbg_sprintf("l%u", reg->regnum);
255  return wine_dbg_sprintf("p%u", reg->regnum);
256  default:
257  return wine_dbg_sprintf("unknown regname %#x", reg->type);
258  }
259 }
260 
261 static const char *debug_print_writemask(DWORD mask)
262 {
263  char ret[6];
264  unsigned char pos = 1;
265 
266  if(mask == BWRITERSP_WRITEMASK_ALL) return "";
267  ret[0] = '.';
268  if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
269  if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
270  if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
271  if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
272  ret[pos] = 0;
273 
274  return wine_dbg_sprintf("%s", ret);
275 }
276 
277 static const char *debug_print_swizzle(DWORD arg)
278 {
279  char ret[6];
280  unsigned int i;
281  DWORD swizzle[4];
282 
283  switch (arg)
284  {
285  case BWRITERVS_NOSWIZZLE:
286  return "";
287  case BWRITERVS_SWIZZLE_X:
288  return ".x";
289  case BWRITERVS_SWIZZLE_Y:
290  return ".y";
291  case BWRITERVS_SWIZZLE_Z:
292  return ".z";
293  case BWRITERVS_SWIZZLE_W:
294  return ".w";
295  }
296 
297  swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
298  swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
299  swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
300  swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
301 
302  ret[0] = '.';
303  for (i = 0; i < 4; ++i)
304  {
305  switch (swizzle[i])
306  {
307  case 0: ret[1 + i] = 'x'; break;
308  case 1: ret[1 + i] = 'y'; break;
309  case 2: ret[1 + i] = 'z'; break;
310  case 3: ret[1 + i] = 'w'; break;
311  }
312  }
313  ret[5] = '\0';
314 
315  return wine_dbg_sprintf("%s", ret);
316 }
317 
318 static const char *debug_print_relarg(const struct shader_reg *reg)
319 {
320  const char *short_swizzle;
321  if (!reg->rel_reg) return "";
322 
323  short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle);
324 
325  if (reg->rel_reg->type == BWRITERSPR_ADDR)
326  return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
327  else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0)
328  return wine_dbg_sprintf("[aL%s]", short_swizzle);
329  else
330  return "Unexpected relative addressing argument";
331 }
332 
333 const char *debug_print_dstreg(const struct shader_reg *reg)
334 {
335  return wine_dbg_sprintf("%s%s%s", get_regname(reg),
337  debug_print_writemask(reg->u.writemask));
338 }
339 
340 const char *debug_print_srcreg(const struct shader_reg *reg)
341 {
342  switch (reg->srcmod)
343  {
344  case BWRITERSPSM_NONE:
345  return wine_dbg_sprintf("%s%s%s", get_regname(reg),
347  debug_print_swizzle(reg->u.swizzle));
348  case BWRITERSPSM_NEG:
349  return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
351  debug_print_swizzle(reg->u.swizzle));
352  case BWRITERSPSM_BIAS:
353  return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
355  debug_print_swizzle(reg->u.swizzle));
356  case BWRITERSPSM_BIASNEG:
357  return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
359  debug_print_swizzle(reg->u.swizzle));
360  case BWRITERSPSM_SIGN:
361  return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
363  debug_print_swizzle(reg->u.swizzle));
364  case BWRITERSPSM_SIGNNEG:
365  return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
367  debug_print_swizzle(reg->u.swizzle));
368  case BWRITERSPSM_COMP:
369  return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
371  debug_print_swizzle(reg->u.swizzle));
372  case BWRITERSPSM_X2:
373  return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
375  debug_print_swizzle(reg->u.swizzle));
376  case BWRITERSPSM_X2NEG:
377  return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
379  debug_print_swizzle(reg->u.swizzle));
380  case BWRITERSPSM_DZ:
381  return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
383  debug_print_swizzle(reg->u.swizzle));
384  case BWRITERSPSM_DW:
385  return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
387  debug_print_swizzle(reg->u.swizzle));
388  case BWRITERSPSM_ABS:
389  return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
391  debug_print_swizzle(reg->u.swizzle));
392  case BWRITERSPSM_ABSNEG:
393  return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
395  debug_print_swizzle(reg->u.swizzle));
396  case BWRITERSPSM_NOT:
397  return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
399  debug_print_swizzle(reg->u.swizzle));
400  }
401  return "Unknown modifier";
402 }
403 
404 const char *debug_print_comp(DWORD comp)
405 {
406  switch (comp)
407  {
408  case BWRITER_COMPARISON_NONE: return "";
409  case BWRITER_COMPARISON_GT: return "_gt";
410  case BWRITER_COMPARISON_EQ: return "_eq";
411  case BWRITER_COMPARISON_GE: return "_ge";
412  case BWRITER_COMPARISON_LT: return "_lt";
413  case BWRITER_COMPARISON_NE: return "_ne";
414  case BWRITER_COMPARISON_LE: return "_le";
415  default: return "_unknown";
416  }
417 }
418 
419 const char *debug_print_opcode(DWORD opcode)
420 {
421  switch (opcode)
422  {
423  case BWRITERSIO_NOP: return "nop";
424  case BWRITERSIO_MOV: return "mov";
425  case BWRITERSIO_ADD: return "add";
426  case BWRITERSIO_SUB: return "sub";
427  case BWRITERSIO_MAD: return "mad";
428  case BWRITERSIO_MUL: return "mul";
429  case BWRITERSIO_RCP: return "rcp";
430  case BWRITERSIO_RSQ: return "rsq";
431  case BWRITERSIO_DP3: return "dp3";
432  case BWRITERSIO_DP4: return "dp4";
433  case BWRITERSIO_MIN: return "min";
434  case BWRITERSIO_MAX: return "max";
435  case BWRITERSIO_SLT: return "slt";
436  case BWRITERSIO_SGE: return "sge";
437  case BWRITERSIO_EXP: return "exp";
438  case BWRITERSIO_LOG: return "log";
439  case BWRITERSIO_LIT: return "lit";
440  case BWRITERSIO_DST: return "dst";
441  case BWRITERSIO_LRP: return "lrp";
442  case BWRITERSIO_FRC: return "frc";
443  case BWRITERSIO_M4x4: return "m4x4";
444  case BWRITERSIO_M4x3: return "m4x3";
445  case BWRITERSIO_M3x4: return "m3x4";
446  case BWRITERSIO_M3x3: return "m3x3";
447  case BWRITERSIO_M3x2: return "m3x2";
448  case BWRITERSIO_CALL: return "call";
449  case BWRITERSIO_CALLNZ: return "callnz";
450  case BWRITERSIO_LOOP: return "loop";
451  case BWRITERSIO_RET: return "ret";
452  case BWRITERSIO_ENDLOOP: return "endloop";
453  case BWRITERSIO_LABEL: return "label";
454  case BWRITERSIO_DCL: return "dcl";
455  case BWRITERSIO_POW: return "pow";
456  case BWRITERSIO_CRS: return "crs";
457  case BWRITERSIO_SGN: return "sgn";
458  case BWRITERSIO_ABS: return "abs";
459  case BWRITERSIO_NRM: return "nrm";
460  case BWRITERSIO_SINCOS: return "sincos";
461  case BWRITERSIO_REP: return "rep";
462  case BWRITERSIO_ENDREP: return "endrep";
463  case BWRITERSIO_IF: return "if";
464  case BWRITERSIO_IFC: return "ifc";
465  case BWRITERSIO_ELSE: return "else";
466  case BWRITERSIO_ENDIF: return "endif";
467  case BWRITERSIO_BREAK: return "break";
468  case BWRITERSIO_BREAKC: return "breakc";
469  case BWRITERSIO_MOVA: return "mova";
470  case BWRITERSIO_DEFB: return "defb";
471  case BWRITERSIO_DEFI: return "defi";
472  case BWRITERSIO_TEXCOORD: return "texcoord";
473  case BWRITERSIO_TEXKILL: return "texkill";
474  case BWRITERSIO_TEX: return "tex";
475  case BWRITERSIO_TEXBEM: return "texbem";
476  case BWRITERSIO_TEXBEML: return "texbeml";
477  case BWRITERSIO_TEXREG2AR: return "texreg2ar";
478  case BWRITERSIO_TEXREG2GB: return "texreg2gb";
479  case BWRITERSIO_TEXM3x2PAD: return "texm3x2pad";
480  case BWRITERSIO_TEXM3x2TEX: return "texm3x2tex";
481  case BWRITERSIO_TEXM3x3PAD: return "texm3x3pad";
482  case BWRITERSIO_TEXM3x3TEX: return "texm3x3tex";
483  case BWRITERSIO_TEXM3x3SPEC: return "texm3x3vspec";
484  case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
485  case BWRITERSIO_EXPP: return "expp";
486  case BWRITERSIO_LOGP: return "logp";
487  case BWRITERSIO_CND: return "cnd";
488  case BWRITERSIO_DEF: return "def";
489  case BWRITERSIO_TEXREG2RGB: return "texreg2rgb";
490  case BWRITERSIO_TEXDP3TEX: return "texdp3tex";
491  case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
492  case BWRITERSIO_TEXDP3: return "texdp3";
493  case BWRITERSIO_TEXM3x3: return "texm3x3";
494  case BWRITERSIO_TEXDEPTH: return "texdepth";
495  case BWRITERSIO_CMP: return "cmp";
496  case BWRITERSIO_BEM: return "bem";
497  case BWRITERSIO_DP2ADD: return "dp2add";
498  case BWRITERSIO_DSX: return "dsx";
499  case BWRITERSIO_DSY: return "dsy";
500  case BWRITERSIO_TEXLDD: return "texldd";
501  case BWRITERSIO_SETP: return "setp";
502  case BWRITERSIO_TEXLDL: return "texldl";
503  case BWRITERSIO_BREAKP: return "breakp";
504  case BWRITERSIO_PHASE: return "phase";
505 
506  case BWRITERSIO_TEXLDP: return "texldp";
507  case BWRITERSIO_TEXLDB: return "texldb";
508 
509  default: return "unknown";
510  }
511 }
512 
513 void skip_dword_unknown(const char **ptr, unsigned int count)
514 {
515  unsigned int i;
516  DWORD d;
517 
518  FIXME("Skipping %u unknown DWORDs:\n", count);
519  for (i = 0; i < count; ++i)
520  {
521  read_dword(ptr, &d);
522  FIXME("\t0x%08x\n", d);
523  }
524 }
525 
526 static void write_dword_unknown(char **ptr, DWORD d)
527 {
528  FIXME("Writing unknown DWORD 0x%08x\n", d);
529  write_dword(ptr, d);
530 }
531 
532 HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size)
533 {
534  TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size);
535 
536  if (dxbc->count >= dxbc->size)
537  {
538  struct dxbc_section *new_sections;
539  DWORD new_size = dxbc->size << 1;
540 
541  new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections));
542  if (!new_sections)
543  {
544  ERR("Failed to allocate dxbc section memory\n");
545  return E_OUTOFMEMORY;
546  }
547 
548  dxbc->sections = new_sections;
549  dxbc->size = new_size;
550  }
551 
552  dxbc->sections[dxbc->count].tag = tag;
553  dxbc->sections[dxbc->count].data_size = data_size;
554  dxbc->sections[dxbc->count].data = data;
555  ++dxbc->count;
556 
557  return S_OK;
558 }
559 
560 HRESULT dxbc_init(struct dxbc *dxbc, unsigned int size)
561 {
562  TRACE("dxbc %p, size %u.\n", dxbc, size);
563 
564  /* use a good starting value for the size if none specified */
565  if (!size) size = 2;
566 
567  dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections));
568  if (!dxbc->sections)
569  {
570  ERR("Failed to allocate dxbc section memory\n");
571  return E_OUTOFMEMORY;
572  }
573 
574  dxbc->size = size;
575  dxbc->count = 0;
576 
577  return S_OK;
578 }
579 
581 {
582  const char *ptr = data;
583  HRESULT hr;
584  unsigned int i;
585  DWORD tag, total_size, chunk_count;
586 
587  if (!data)
588  {
589  WARN("No data supplied.\n");
590  return E_FAIL;
591  }
592 
593  read_dword(&ptr, &tag);
594  TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
595 
596  if (tag != TAG_DXBC)
597  {
598  WARN("Wrong tag.\n");
599  return E_FAIL;
600  }
601 
602  /* checksum? */
603  skip_dword_unknown(&ptr, 4);
604 
605  skip_dword_unknown(&ptr, 1);
606 
607  read_dword(&ptr, &total_size);
608  TRACE("total size: %#x\n", total_size);
609 
610  if (data_size != total_size)
611  {
612  WARN("Wrong size supplied.\n");
613  return D3DERR_INVALIDCALL;
614  }
615 
616  read_dword(&ptr, &chunk_count);
617  TRACE("chunk count: %#x\n", chunk_count);
618 
619  hr = dxbc_init(dxbc, chunk_count);
620  if (FAILED(hr))
621  {
622  WARN("Failed to init dxbc\n");
623  return hr;
624  }
625 
626  for (i = 0; i < chunk_count; ++i)
627  {
628  DWORD chunk_tag, chunk_size;
629  const char *chunk_ptr;
630  DWORD chunk_offset;
631 
632  read_dword(&ptr, &chunk_offset);
633  TRACE("chunk %u at offset %#x\n", i, chunk_offset);
634 
635  chunk_ptr = data + chunk_offset;
636 
637  read_dword(&chunk_ptr, &chunk_tag);
638  read_dword(&chunk_ptr, &chunk_size);
639 
640  hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size);
641  if (FAILED(hr))
642  {
643  WARN("Failed to add section to dxbc\n");
644  return hr;
645  }
646  }
647 
648  return hr;
649 }
650 
651 void dxbc_destroy(struct dxbc *dxbc)
652 {
653  TRACE("dxbc %p.\n", dxbc);
654 
656 }
657 
659 {
660  DWORD size = 32, offset = size + 4 * dxbc->count;
661  ID3DBlob *object;
662  HRESULT hr;
663  char *ptr;
664  unsigned int i;
665 
666  TRACE("dxbc %p, blob %p.\n", dxbc, blob);
667 
668  for (i = 0; i < dxbc->count; ++i)
669  {
670  size += 12 + dxbc->sections[i].data_size;
671  }
672 
673  hr = D3DCreateBlob(size, &object);
674  if (FAILED(hr))
675  {
676  WARN("Failed to create blob\n");
677  return hr;
678  }
679 
680  ptr = ID3D10Blob_GetBufferPointer(object);
681 
683 
684  /* signature(?) */
689 
690  /* seems to be always 1 */
692 
693  /* DXBC size */
694  write_dword(&ptr, size);
695 
696  /* chunk count */
698 
699  /* write the chunk offsets */
700  for (i = 0; i < dxbc->count; ++i)
701  {
703  offset += 8 + dxbc->sections[i].data_size;
704  }
705 
706  /* write the chunks */
707  for (i = 0; i < dxbc->count; ++i)
708  {
709  write_dword(&ptr, dxbc->sections[i].tag);
710  write_dword(&ptr, dxbc->sections[i].data_size);
711  memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size);
712  ptr += dxbc->sections[i].data_size;
713  }
714 
715  TRACE("Created ID3DBlob %p\n", object);
716 
717  *blob = object;
718 
719  return S_OK;
720 }
721 
723 {
724  char* buffer;
725  int rc, size;
726 
727  if (msg->capacity == 0)
728  {
730  if (msg->string == NULL)
731  {
732  ERR("Error allocating memory for parser messages\n");
733  return;
734  }
735  msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
736  }
737 
738  while (1)
739  {
740  rc = vsnprintf(msg->string + msg->size,
741  msg->capacity - msg->size, fmt, args);
742 
743  if (rc < 0 || rc >= msg->capacity - msg->size)
744  {
745  size = msg->capacity * 2;
746  buffer = d3dcompiler_realloc(msg->string, size);
747  if (buffer == NULL)
748  {
749  ERR("Error reallocating memory for parser messages\n");
750  return;
751  }
752  msg->string = buffer;
753  msg->capacity = size;
754  }
755  else
756  {
757  TRACE("%s", msg->string + msg->size);
758  msg->size += rc;
759  return;
760  }
761  }
762 }
763 
764 BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
765 {
766  struct hlsl_ir_var *var;
767 
768  LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
769  {
770  if (!strcmp(decl->name, var->name))
771  return FALSE;
772  }
773  if (local_var && scope->upper->upper == hlsl_ctx.globals)
774  {
775  /* Check whether the variable redefines a function parameter. */
776  LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
777  {
778  if (!strcmp(decl->name, var->name))
779  return FALSE;
780  }
781  }
782 
783  list_add_tail(&scope->vars, &decl->scope_entry);
784  return TRUE;
785 }
786 
787 struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name)
788 {
789  struct hlsl_ir_var *var;
790 
791  LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
792  {
793  if (!strcmp(name, var->name))
794  return var;
795  }
796  if (!scope->upper)
797  return NULL;
798  return get_variable(scope->upper, name);
799 }
800 
801 void free_declaration(struct hlsl_ir_var *decl)
802 {
803  d3dcompiler_free((void *)decl->name);
804  d3dcompiler_free((void *)decl->semantic);
805  d3dcompiler_free((void *)decl->reg_reservation);
806  d3dcompiler_free(decl);
807 }
808 
809 struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_type_class type_class,
810  enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
811 {
812  struct hlsl_type *type;
813 
814  type = d3dcompiler_alloc(sizeof(*type));
815  if (!type)
816  {
817  ERR("Out of memory\n");
818  return NULL;
819  }
820  type->name = name;
821  type->type = type_class;
822  type->base_type = base_type;
823  type->dimx = dimx;
824  type->dimy = dimy;
825 
826  list_add_tail(&hlsl_ctx.types, &type->entry);
827 
828  return type;
829 }
830 
831 struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size)
832 {
834 
835  if (!type)
836  return NULL;
837 
838  type->modifiers = basic_type->modifiers;
839  type->e.array.elements_count = array_size;
840  type->e.array.type = basic_type;
841  return type;
842 }
843 
844 struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive)
845 {
846  struct wine_rb_entry *entry = wine_rb_get(&scope->types, name);
847  if (entry)
848  return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
849 
850  if (recursive && scope->upper)
851  return get_type(scope->upper, name, recursive);
852  return NULL;
853 }
854 
855 BOOL find_function(const char *name)
856 {
857  return wine_rb_get(&hlsl_ctx.functions, name) != NULL;
858 }
859 
860 unsigned int components_count_type(struct hlsl_type *type)
861 {
862  unsigned int count = 0;
863  struct hlsl_struct_field *field;
864 
865  if (type->type <= HLSL_CLASS_LAST_NUMERIC)
866  {
867  return type->dimx * type->dimy;
868  }
869  if (type->type == HLSL_CLASS_ARRAY)
870  {
871  return components_count_type(type->e.array.type) * type->e.array.elements_count;
872  }
873  if (type->type != HLSL_CLASS_STRUCT)
874  {
875  ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
876  return 0;
877  }
878 
879  LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
880  {
882  }
883  return count;
884 }
885 
886 BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
887 {
888  if (t1 == t2)
889  return TRUE;
890 
891  if (t1->type != t2->type)
892  return FALSE;
893  if (t1->base_type != t2->base_type)
894  return FALSE;
895  if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
896  return FALSE;
899  return FALSE;
900  if (t1->dimx != t2->dimx)
901  return FALSE;
902  if (t1->dimy != t2->dimy)
903  return FALSE;
904  if (t1->type == HLSL_CLASS_STRUCT)
905  {
906  struct list *t1cur, *t2cur;
907  struct hlsl_struct_field *t1field, *t2field;
908 
909  t1cur = list_head(t1->e.elements);
910  t2cur = list_head(t2->e.elements);
911  while (t1cur && t2cur)
912  {
913  t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
914  t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
915  if (!compare_hlsl_types(t1field->type, t2field->type))
916  return FALSE;
917  if (strcmp(t1field->name, t2field->name))
918  return FALSE;
919  t1cur = list_next(t1->e.elements, t1cur);
920  t2cur = list_next(t2->e.elements, t2cur);
921  }
922  if (t1cur != t2cur)
923  return FALSE;
924  }
925  if (t1->type == HLSL_CLASS_ARRAY)
926  return t1->e.array.elements_count == t2->e.array.elements_count
927  && compare_hlsl_types(t1->e.array.type, t2->e.array.type);
928 
929  return TRUE;
930 }
931 
932 struct hlsl_type *clone_hlsl_type(struct hlsl_type *old)
933 {
934  struct hlsl_type *type;
935  struct hlsl_struct_field *old_field, *field;
936 
937  type = d3dcompiler_alloc(sizeof(*type));
938  if (!type)
939  {
940  ERR("Out of memory\n");
941  return NULL;
942  }
943  if (old->name)
944  {
945  type->name = d3dcompiler_strdup(old->name);
946  if (!type->name)
947  {
949  return NULL;
950  }
951  }
952  type->type = old->type;
953  type->base_type = old->base_type;
954  type->dimx = old->dimx;
955  type->dimy = old->dimy;
956  type->modifiers = old->modifiers;
957  type->sampler_dim = old->sampler_dim;
958  switch (old->type)
959  {
960  case HLSL_CLASS_ARRAY:
961  type->e.array.type = old->e.array.type;
962  type->e.array.elements_count = old->e.array.elements_count;
963  break;
964  case HLSL_CLASS_STRUCT:
965  type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements));
966  if (!type->e.elements)
967  {
968  d3dcompiler_free((void *)type->name);
970  return NULL;
971  }
972  list_init(type->e.elements);
973  LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry)
974  {
975  field = d3dcompiler_alloc(sizeof(*field));
976  if (!field)
977  {
978  LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry)
979  {
980  d3dcompiler_free((void *)field->semantic);
981  d3dcompiler_free((void *)field->name);
983  }
984  d3dcompiler_free(type->e.elements);
985  d3dcompiler_free((void *)type->name);
987  return NULL;
988  }
989  field->type = clone_hlsl_type(old_field->type);
990  field->name = d3dcompiler_strdup(old_field->name);
991  if (old_field->semantic)
992  field->semantic = d3dcompiler_strdup(old_field->semantic);
993  field->modifiers = old_field->modifiers;
994  list_add_tail(type->e.elements, &field->entry);
995  }
996  break;
997  default:
998  break;
999  }
1000 
1001  list_add_tail(&hlsl_ctx.types, &type->entry);
1002  return type;
1003 }
1004 
1006 {
1007  return type->type != HLSL_CLASS_OBJECT;
1008 }
1009 
1011 {
1013  return FALSE;
1014 
1015  if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
1016  {
1017  /* Scalar vars can be cast to pretty much everything */
1018  if (t1->dimx == 1 && t1->dimy == 1)
1019  return TRUE;
1020 
1021  if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
1022  return t1->dimx >= t2->dimx;
1023  }
1024 
1025  /* The other way around is true too i.e. whatever to scalar */
1026  if (t2->type <= HLSL_CLASS_LAST_NUMERIC && t2->dimx == 1 && t2->dimy == 1)
1027  return TRUE;
1028 
1029  if (t1->type == HLSL_CLASS_ARRAY)
1030  {
1031  if (compare_hlsl_types(t1->e.array.type, t2))
1032  /* e.g. float4[3] to float4 is allowed */
1033  return TRUE;
1034 
1035  if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
1036  return components_count_type(t1) >= components_count_type(t2);
1037  else
1038  return components_count_type(t1) == components_count_type(t2);
1039  }
1040 
1041  if (t1->type == HLSL_CLASS_STRUCT)
1042  return components_count_type(t1) >= components_count_type(t2);
1043 
1044  if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
1045  return components_count_type(t1) == components_count_type(t2);
1046 
1047  if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1048  {
1049  if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1050  return TRUE;
1051 
1052  /* Matrix-vector conversion is apparently allowed if they have the same components count */
1053  if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1055  return TRUE;
1056  return FALSE;
1057  }
1058 
1060  return TRUE;
1061  return FALSE;
1062 }
1063 
1065 {
1067  return FALSE;
1068 
1069  if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
1070  {
1071  /* Scalar vars can be converted to any other numeric data type */
1072  if (t1->dimx == 1 && t1->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1073  return TRUE;
1074  /* The other way around is true too */
1075  if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1076  return TRUE;
1077  }
1078 
1079  if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY)
1080  {
1081  return components_count_type(t1) == components_count_type(t2);
1082  }
1083 
1084  if ((t1->type == HLSL_CLASS_ARRAY && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1085  || (t1->type <= HLSL_CLASS_LAST_NUMERIC && t2->type == HLSL_CLASS_ARRAY))
1086  {
1087  /* e.g. float4[3] to float4 is allowed */
1088  if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2))
1089  return TRUE;
1091  return TRUE;
1092  return FALSE;
1093  }
1094 
1095  if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR)
1096  {
1097  if (t1->dimx >= t2->dimx)
1098  return TRUE;
1099  return FALSE;
1100  }
1101 
1102  if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1103  {
1104  if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX
1105  && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1106  return TRUE;
1107 
1108  /* Matrix-vector conversion is apparently allowed if they have the same components count */
1109  if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1111  return TRUE;
1112  return FALSE;
1113  }
1114 
1115  if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT)
1116  return compare_hlsl_types(t1, t2);
1117 
1118  return FALSE;
1119 }
1120 
1121 static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1122 {
1124  return FALSE;
1125 
1126  /* Scalar vars can be converted to pretty much everything */
1127  if ((t1->dimx == 1 && t1->dimy == 1) || (t2->dimx == 1 && t2->dimy == 1))
1128  return TRUE;
1129 
1130  if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
1131  return TRUE;
1132 
1133  if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1134  {
1135  /* Matrix-vector conversion is apparently allowed if either they have the same components
1136  count or the matrix is nx1 or 1xn */
1137  if (t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1138  {
1140  return TRUE;
1141 
1142  return (t1->type == HLSL_CLASS_MATRIX && (t1->dimx == 1 || t1->dimy == 1))
1143  || (t2->type == HLSL_CLASS_MATRIX && (t2->dimx == 1 || t2->dimy == 1));
1144  }
1145 
1146  /* Both matrices */
1147  if ((t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1148  || (t1->dimx <= t2->dimx && t1->dimy <= t2->dimy))
1149  return TRUE;
1150  }
1151 
1152  return FALSE;
1153 }
1154 
1156 {
1157  static const enum hlsl_base_type types[] =
1158  {
1160  HLSL_TYPE_INT,
1165  };
1166  int t1_idx = -1, t2_idx = -1, i;
1167 
1168  for (i = 0; i < ARRAY_SIZE(types); ++i)
1169  {
1170  /* Always convert away from HLSL_TYPE_HALF */
1171  if (t1 == types[i])
1172  t1_idx = t1 == HLSL_TYPE_HALF ? i + 1 : i;
1173  if (t2 == types[i])
1174  t2_idx = t2 == HLSL_TYPE_HALF ? i + 1 : i;
1175 
1176  if (t1_idx != -1 && t2_idx != -1)
1177  break;
1178  }
1179  if (t1_idx == -1 || t2_idx == -1)
1180  {
1181  FIXME("Unexpected base type.\n");
1182  return HLSL_TYPE_FLOAT;
1183  }
1184  return t1_idx >= t2_idx ? t1 : t2;
1185 }
1186 
1187 static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2,
1188  struct source_location *loc)
1189 {
1190  enum hlsl_type_class type;
1191  enum hlsl_base_type base;
1192  unsigned int dimx, dimy;
1193 
1195  {
1196  hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
1197  "non scalar/vector/matrix data type in expression");
1198  return NULL;
1199  }
1200 
1201  if (compare_hlsl_types(t1, t2))
1202  return t1;
1203 
1204  if (!expr_compatible_data_types(t1, t2))
1205  {
1206  hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
1207  "expression data types are incompatible");
1208  return NULL;
1209  }
1210 
1211  if (t1->base_type == t2->base_type)
1212  base = t1->base_type;
1213  else
1215 
1216  if (t1->dimx == 1 && t1->dimy == 1)
1217  {
1218  type = t2->type;
1219  dimx = t2->dimx;
1220  dimy = t2->dimy;
1221  }
1222  else if (t2->dimx == 1 && t2->dimy == 1)
1223  {
1224  type = t1->type;
1225  dimx = t1->dimx;
1226  dimy = t1->dimy;
1227  }
1228  else if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX)
1229  {
1231  dimx = min(t1->dimx, t2->dimx);
1232  dimy = min(t1->dimy, t2->dimy);
1233  }
1234  else
1235  {
1236  /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1237  unsigned int max_dim_1, max_dim_2;
1238 
1239  max_dim_1 = max(t1->dimx, t1->dimy);
1240  max_dim_2 = max(t2->dimx, t2->dimy);
1241  if (t1->dimx * t1->dimy == t2->dimx * t2->dimy)
1242  {
1244  dimx = max(t1->dimx, t2->dimx);
1245  dimy = 1;
1246  }
1247  else if (max_dim_1 <= max_dim_2)
1248  {
1249  type = t1->type;
1250  if (type == HLSL_CLASS_VECTOR)
1251  {
1252  dimx = max_dim_1;
1253  dimy = 1;
1254  }
1255  else
1256  {
1257  dimx = t1->dimx;
1258  dimy = t1->dimy;
1259  }
1260  }
1261  else
1262  {
1263  type = t2->type;
1264  if (type == HLSL_CLASS_VECTOR)
1265  {
1266  dimx = max_dim_2;
1267  dimy = 1;
1268  }
1269  else
1270  {
1271  dimx = t2->dimx;
1272  dimy = t2->dimy;
1273  }
1274  }
1275  }
1276 
1277  return new_hlsl_type(NULL, type, base, dimx, dimy);
1278 }
1279 
1281  struct source_location *loc)
1282 {
1283  struct hlsl_ir_expr *cast;
1284  struct hlsl_ir_node *operands[3];
1285 
1286  if (compare_hlsl_types(node->data_type, type))
1287  return node;
1288  TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type));
1289  operands[0] = node;
1290  operands[1] = operands[2] = NULL;
1291  cast = new_expr(HLSL_IR_UNOP_CAST, operands, loc);
1292  if (!cast)
1293  return NULL;
1294  cast->node.data_type = type;
1295  return &cast->node;
1296 }
1297 
1299  struct source_location *loc)
1300 {
1301  struct hlsl_ir_expr *expr = d3dcompiler_alloc(sizeof(*expr));
1302  struct hlsl_type *type;
1303  unsigned int i;
1304 
1305  if (!expr)
1306  {
1307  ERR("Out of memory\n");
1308  return NULL;
1309  }
1310  expr->node.type = HLSL_IR_EXPR;
1311  expr->node.loc = *loc;
1312  type = operands[0]->data_type;
1313  for (i = 1; i <= 2; ++i)
1314  {
1315  if (!operands[i])
1316  break;
1317  type = expr_common_type(type, operands[i]->data_type, loc);
1318  if (!type)
1319  {
1321  return NULL;
1322  }
1323  }
1324  for (i = 0; i <= 2; ++i)
1325  {
1326  if (!operands[i])
1327  break;
1328  if (compare_hlsl_types(operands[i]->data_type, type))
1329  continue;
1330  TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands[i]->data_type), debug_hlsl_type(type));
1331  if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1
1332  && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy)
1333  {
1334  hlsl_report_message(operands[i]->loc.file,
1335  operands[i]->loc.line, operands[i]->loc.col, HLSL_LEVEL_WARNING,
1336  "implicit truncation of vector/matrix type");
1337  }
1338  operands[i] = implicit_conversion(operands[i], type, &operands[i]->loc);
1339  if (!operands[i])
1340  {
1341  ERR("Impossible to convert expression operand %u to %s\n", i + 1, debug_hlsl_type(type));
1343  return NULL;
1344  }
1345  }
1346  expr->node.data_type = type;
1347  expr->op = op;
1348  expr->operands[0] = operands[0];
1349  expr->operands[1] = operands[1];
1350  expr->operands[2] = operands[2];
1351 
1352  return expr;
1353 }
1354 
1356  struct source_location *loc)
1357 {
1358  struct hlsl_ir_expr *cast;
1359  struct hlsl_ir_node *operands[3];
1360 
1361  operands[0] = node;
1362  operands[1] = operands[2] = NULL;
1363  cast = new_expr(HLSL_IR_UNOP_CAST, operands, loc);
1364  if (cast)
1365  cast->node.data_type = type;
1366  return cast;
1367 }
1368 
1369 struct hlsl_ir_expr *hlsl_mul(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1370  struct source_location *loc)
1371 {
1372  struct hlsl_ir_expr *expr;
1373  struct hlsl_ir_node *ops[3];
1374 
1375  ops[0] = op1;
1376  ops[1] = op2;
1377  ops[2] = NULL;
1379  return expr;
1380 }
1381 
1382 struct hlsl_ir_expr *hlsl_div(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1383  struct source_location *loc)
1384 {
1385  struct hlsl_ir_expr *expr;
1386  struct hlsl_ir_node *ops[3];
1387 
1388  ops[0] = op1;
1389  ops[1] = op2;
1390  ops[2] = NULL;
1392  return expr;
1393 }
1394 
1395 struct hlsl_ir_expr *hlsl_mod(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1396  struct source_location *loc)
1397 {
1398  struct hlsl_ir_expr *expr;
1399  struct hlsl_ir_node *ops[3];
1400 
1401  ops[0] = op1;
1402  ops[1] = op2;
1403  ops[2] = NULL;
1405  return expr;
1406 }
1407 
1408 struct hlsl_ir_expr *hlsl_add(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1409  struct source_location *loc)
1410 {
1411  struct hlsl_ir_expr *expr;
1412  struct hlsl_ir_node *ops[3];
1413 
1414  ops[0] = op1;
1415  ops[1] = op2;
1416  ops[2] = NULL;
1418  return expr;
1419 }
1420 
1421 struct hlsl_ir_expr *hlsl_sub(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1422  struct source_location *loc)
1423 {
1424  struct hlsl_ir_expr *expr;
1425  struct hlsl_ir_node *ops[3];
1426 
1427  ops[0] = op1;
1428  ops[1] = op2;
1429  ops[2] = NULL;
1431  return expr;
1432 }
1433 
1434 struct hlsl_ir_expr *hlsl_lt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1435  struct source_location *loc)
1436 {
1437  struct hlsl_ir_expr *expr;
1438  struct hlsl_ir_node *ops[3];
1439 
1440  ops[0] = op1;
1441  ops[1] = op2;
1442  ops[2] = NULL;
1444  return expr;
1445 }
1446 
1447 struct hlsl_ir_expr *hlsl_gt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1448  struct source_location *loc)
1449 {
1450  struct hlsl_ir_expr *expr;
1451  struct hlsl_ir_node *ops[3];
1452 
1453  ops[0] = op1;
1454  ops[1] = op2;
1455  ops[2] = NULL;
1457  return expr;
1458 }
1459 
1460 struct hlsl_ir_expr *hlsl_le(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1461  struct source_location *loc)
1462 {
1463  struct hlsl_ir_expr *expr;
1464  struct hlsl_ir_node *ops[3];
1465 
1466  ops[0] = op1;
1467  ops[1] = op2;
1468  ops[2] = NULL;
1470  return expr;
1471 }
1472 
1473 struct hlsl_ir_expr *hlsl_ge(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1474  struct source_location *loc)
1475 {
1476  struct hlsl_ir_expr *expr;
1477  struct hlsl_ir_node *ops[3];
1478 
1479  ops[0] = op1;
1480  ops[1] = op2;
1481  ops[2] = NULL;
1483  return expr;
1484 }
1485 
1486 struct hlsl_ir_expr *hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1487  struct source_location *loc)
1488 {
1489  struct hlsl_ir_expr *expr;
1490  struct hlsl_ir_node *ops[3];
1491 
1492  ops[0] = op1;
1493  ops[1] = op2;
1494  ops[2] = NULL;
1496  return expr;
1497 }
1498 
1499 struct hlsl_ir_expr *hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1500  struct source_location *loc)
1501 {
1502  struct hlsl_ir_expr *expr;
1503  struct hlsl_ir_node *ops[3];
1504 
1505  ops[0] = op1;
1506  ops[1] = op2;
1507  ops[2] = NULL;
1509  return expr;
1510 }
1511 
1513 {
1514  struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
1515 
1516  if (!deref)
1517  {
1518  ERR("Out of memory.\n");
1519  return NULL;
1520  }
1521  deref->node.type = HLSL_IR_DEREF;
1522  deref->node.data_type = var->node.data_type;
1523  deref->type = HLSL_IR_DEREF_VAR;
1524  deref->v.var = var;
1525  return deref;
1526 }
1527 
1529 {
1530  struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
1531 
1532  if (!deref)
1533  {
1534  ERR("Out of memory.\n");
1535  return NULL;
1536  }
1537  deref->node.type = HLSL_IR_DEREF;
1538  deref->node.data_type = field->type;
1539  deref->type = HLSL_IR_DEREF_RECORD;
1540  if (record->type == HLSL_IR_VAR)
1541  deref->v.record.record = &new_var_deref(var_from_node(record))->node;
1542  else
1543  deref->v.record.record = record;
1544  deref->v.record.field = field;
1545  return deref;
1546 }
1547 
1549 {
1550  static const enum hlsl_ir_expr_op ops[] =
1551  {
1552  0,
1563  };
1564 
1565  return ops[op];
1566 }
1567 
1569  DWORD writemask, struct hlsl_ir_node *right)
1570 {
1571  struct hlsl_ir_expr *expr;
1572  struct hlsl_ir_assignment *assign = d3dcompiler_alloc(sizeof(*assign));
1573  struct hlsl_type *type;
1574  struct hlsl_ir_node *lhs, *rhs;
1575 
1576  if (!assign)
1577  {
1578  ERR("Out of memory\n");
1579  return NULL;
1580  }
1581 
1582  TRACE("Creating proper assignment expression.\n");
1583  rhs = right;
1584  if (writemask == BWRITERSP_WRITEMASK_ALL)
1585  type = left->data_type;
1586  else
1587  {
1588  unsigned int dimx = 0;
1589  DWORD bitmask;
1590  enum hlsl_type_class type_class;
1591 
1592  if (left->data_type->type > HLSL_CLASS_LAST_NUMERIC)
1593  {
1594  hlsl_report_message(left->loc.file, left->loc.line, left->loc.col, HLSL_LEVEL_ERROR,
1595  "writemask on a non scalar/vector/matrix type");
1596  d3dcompiler_free(assign);
1597  return NULL;
1598  }
1599  bitmask = writemask & ((1 << left->data_type->dimx) - 1);
1600  while (bitmask)
1601  {
1602  if (bitmask & 1)
1603  dimx++;
1604  bitmask >>= 1;
1605  }
1606  if (left->data_type->type == HLSL_CLASS_MATRIX)
1607  FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n");
1608  if (dimx == 1)
1609  type_class = HLSL_CLASS_SCALAR;
1610  else
1611  type_class = left->data_type->type;
1612  type = new_hlsl_type(NULL, type_class, left->data_type->base_type, dimx, 1);
1613  }
1614  assign->node.type = HLSL_IR_ASSIGNMENT;
1615  assign->node.loc = left->loc;
1616  assign->node.data_type = type;
1617  assign->writemask = writemask;
1618  FIXME("Check for casts in the lhs.\n");
1619 
1620  lhs = left;
1621  if (lhs->type == HLSL_IR_VAR)
1622  {
1623  struct hlsl_ir_deref *lhs_deref = new_var_deref(var_from_node(lhs));
1624  lhs = &lhs_deref->node;
1625  }
1626  /* FIXME: check for invalid writemasks on the lhs. */
1627 
1628  if (!compare_hlsl_types(type, rhs->data_type))
1629  {
1630  struct hlsl_ir_node *converted_rhs;
1631 
1633  {
1634  hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_ERROR,
1635  "can't implicitly convert %s to %s",
1637  free_instr(lhs);
1638  free_instr(rhs);
1639  d3dcompiler_free(assign);
1640  return NULL;
1641  }
1642  if (lhs->data_type->dimx * lhs->data_type->dimy < rhs->data_type->dimx * rhs->data_type->dimy)
1643  hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_WARNING,
1644  "implicit truncation of vector type");
1645 
1646  converted_rhs = implicit_conversion(rhs, type, &rhs->loc);
1647  if (!converted_rhs)
1648  {
1649  ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type));
1650  free_instr(lhs);
1651  free_instr(rhs);
1652  d3dcompiler_free(assign);
1653  return NULL;
1654  }
1655  rhs = converted_rhs;
1656  }
1657 
1658  assign->lhs = lhs;
1659  if (assign_op != ASSIGN_OP_ASSIGN)
1660  {
1661  struct hlsl_ir_node *operands[3];
1662  enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
1663 
1664  if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR)
1665  {
1666  FIXME("LHS expression not supported in compound assignments yet.\n");
1667  assign->rhs = rhs;
1668  }
1669  else
1670  {
1671  struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref;
1672 
1673  TRACE("Adding an expression for the compound assignment.\n");
1674  new_deref = new_var_deref(lhs_deref->v.var);
1675  operands[0] = &new_deref->node;
1676  operands[1] = rhs;
1677  operands[2] = NULL;
1678  expr = new_expr(op, operands, &left->loc);
1679  assign->rhs = &expr->node;
1680  }
1681  }
1682  else
1683  assign->rhs = rhs;
1684 
1685  return &assign->node;
1686 }
1687 
1688 static int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry)
1689 {
1690  const char *name = key;
1691  const struct hlsl_type *type = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_type, scope_entry);
1692 
1693  if (name == type->name)
1694  return 0;
1695 
1696  if (!name || !type->name)
1697  {
1698  ERR("hlsl_type without a name in a scope?\n");
1699  return -1;
1700  }
1701  return strcmp(name, type->name);
1702 }
1703 
1704 void push_scope(struct hlsl_parse_ctx *ctx)
1705 {
1706  struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
1707 
1708  if (!new_scope)
1709  {
1710  ERR("Out of memory!\n");
1711  return;
1712  }
1713  TRACE("Pushing a new scope\n");
1714  list_init(&new_scope->vars);
1716  new_scope->upper = ctx->cur_scope;
1717  ctx->cur_scope = new_scope;
1718  list_add_tail(&ctx->scopes, &new_scope->entry);
1719 }
1720 
1722 {
1723  struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
1724  if (!prev_scope)
1725  return FALSE;
1726 
1727  TRACE("Popping current scope\n");
1728  ctx->cur_scope = prev_scope;
1729  return TRUE;
1730 }
1731 
1732 struct hlsl_ir_function_decl *new_func_decl(struct hlsl_type *return_type, struct list *parameters)
1733 {
1734  struct hlsl_ir_function_decl *decl;
1735 
1736  decl = d3dcompiler_alloc(sizeof(*decl));
1737  if (!decl)
1738  {
1739  ERR("Out of memory.\n");
1740  return NULL;
1741  }
1742  decl->node.type = HLSL_IR_FUNCTION_DECL;
1743  decl->node.data_type = return_type;
1744  decl->parameters = parameters;
1745 
1746  return decl;
1747 }
1748 
1749 static int compare_param_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
1750 {
1751  if (t1->type != t2->type)
1752  {
1753  if (!((t1->type == HLSL_CLASS_SCALAR && t2->type == HLSL_CLASS_VECTOR)
1754  || (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_SCALAR)))
1755  return t1->type - t2->type;
1756  }
1757  if (t1->base_type != t2->base_type)
1758  return t1->base_type - t2->base_type;
1759  if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
1760  return t1->sampler_dim - t2->sampler_dim;
1761  if (t1->dimx != t2->dimx)
1762  return t1->dimx - t2->dimx;
1763  if (t1->dimy != t2->dimy)
1764  return t1->dimx - t2->dimx;
1765  if (t1->type == HLSL_CLASS_STRUCT)
1766  {
1767  struct list *t1cur, *t2cur;
1768  struct hlsl_struct_field *t1field, *t2field;
1769  int r;
1770 
1771  t1cur = list_head(t1->e.elements);
1772  t2cur = list_head(t2->e.elements);
1773  while (t1cur && t2cur)
1774  {
1775  t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
1776  t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
1777  if ((r = compare_param_hlsl_types(t1field->type, t2field->type)))
1778  return r;
1779  if ((r = strcmp(t1field->name, t2field->name)))
1780  return r;
1781  t1cur = list_next(t1->e.elements, t1cur);
1782  t2cur = list_next(t2->e.elements, t2cur);
1783  }
1784  if (t1cur != t2cur)
1785  return t1cur ? 1 : -1;
1786  return 0;
1787  }
1788  if (t1->type == HLSL_CLASS_ARRAY)
1789  {
1790  if (t1->e.array.elements_count != t2->e.array.elements_count)
1791  return t1->e.array.elements_count - t2->e.array.elements_count;
1792  return compare_param_hlsl_types(t1->e.array.type, t2->e.array.type);
1793  }
1794 
1795  return 0;
1796 }
1797 
1798 static int compare_function_decl_rb(const void *key, const struct wine_rb_entry *entry)
1799 {
1800  const struct list *params = key;
1801  const struct hlsl_ir_function_decl *decl = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function_decl, entry);
1802  int params_count = params ? list_count(params) : 0;
1803  int decl_params_count = decl->parameters ? list_count(decl->parameters) : 0;
1804  int r;
1805  struct list *p1cur, *p2cur;
1806 
1807  if (params_count != decl_params_count)
1808  return params_count - decl_params_count;
1809 
1810  p1cur = params ? list_head(params) : NULL;
1811  p2cur = decl->parameters ? list_head(decl->parameters) : NULL;
1812  while (p1cur && p2cur)
1813  {
1814  struct hlsl_ir_var *p1, *p2;
1815  p1 = LIST_ENTRY(p1cur, struct hlsl_ir_var, node.entry);
1816  p2 = LIST_ENTRY(p2cur, struct hlsl_ir_var, node.entry);
1817  if ((r = compare_param_hlsl_types(p1->node.data_type, p2->node.data_type)))
1818  return r;
1819  p1cur = list_next(params, p1cur);
1820  p2cur = list_next(decl->parameters, p2cur);
1821  }
1822  return 0;
1823 }
1824 
1825 static int compare_function_rb(const void *key, const struct wine_rb_entry *entry)
1826 {
1827  const char *name = key;
1828  const struct hlsl_ir_function *func = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function,entry);
1829 
1830  return strcmp(name, func->name);
1831 }
1832 
1834 {
1836 }
1837 
1838 static const char *debug_base_type(const struct hlsl_type *type)
1839 {
1840  const char *name = "(unknown)";
1841 
1842  switch (type->base_type)
1843  {
1844  case HLSL_TYPE_FLOAT: name = "float"; break;
1845  case HLSL_TYPE_HALF: name = "half"; break;
1846  case HLSL_TYPE_DOUBLE: name = "double"; break;
1847  case HLSL_TYPE_INT: name = "int"; break;
1848  case HLSL_TYPE_UINT: name = "uint"; break;
1849  case HLSL_TYPE_BOOL: name = "bool"; break;
1850  case HLSL_TYPE_SAMPLER:
1851  switch (type->sampler_dim)
1852  {
1853  case HLSL_SAMPLER_DIM_GENERIC: name = "sampler"; break;
1854  case HLSL_SAMPLER_DIM_1D: name = "sampler1D"; break;
1855  case HLSL_SAMPLER_DIM_2D: name = "sampler2D"; break;
1856  case HLSL_SAMPLER_DIM_3D: name = "sampler3D"; break;
1857  case HLSL_SAMPLER_DIM_CUBE: name = "samplerCUBE"; break;
1858  }
1859  break;
1860  default:
1861  FIXME("Unhandled case %u\n", type->base_type);
1862  }
1863  return name;
1864 }
1865 
1866 const char *debug_hlsl_type(const struct hlsl_type *type)
1867 {
1868  const char *name;
1869 
1870  if (type->name)
1871  return debugstr_a(type->name);
1872 
1873  if (type->type == HLSL_CLASS_STRUCT)
1874  return "<anonymous struct>";
1875 
1876  if (type->type == HLSL_CLASS_ARRAY)
1877  {
1878  name = debug_base_type(type->e.array.type);
1879  return wine_dbg_sprintf("%s[%u]", name, type->e.array.elements_count);
1880  }
1881 
1883 
1884  if (type->type == HLSL_CLASS_SCALAR)
1885  return wine_dbg_sprintf("%s", name);
1886  if (type->type == HLSL_CLASS_VECTOR)
1887  return wine_dbg_sprintf("%s%u", name, type->dimx);
1888  if (type->type == HLSL_CLASS_MATRIX)
1889  return wine_dbg_sprintf("%s%ux%u", name, type->dimx, type->dimy);
1890  return "unexpected_type";
1891 }
1892 
1893 const char *debug_modifiers(DWORD modifiers)
1894 {
1895  char string[110];
1896 
1897  string[0] = 0;
1898  if (modifiers & HLSL_STORAGE_EXTERN)
1899  strcat(string, " extern"); /* 7 */
1900  if (modifiers & HLSL_STORAGE_NOINTERPOLATION)
1901  strcat(string, " nointerpolation"); /* 16 */
1902  if (modifiers & HLSL_MODIFIER_PRECISE)
1903  strcat(string, " precise"); /* 8 */
1904  if (modifiers & HLSL_STORAGE_SHARED)
1905  strcat(string, " shared"); /* 7 */
1906  if (modifiers & HLSL_STORAGE_GROUPSHARED)
1907  strcat(string, " groupshared"); /* 12 */
1908  if (modifiers & HLSL_STORAGE_STATIC)
1909  strcat(string, " static"); /* 7 */
1910  if (modifiers & HLSL_STORAGE_UNIFORM)
1911  strcat(string, " uniform"); /* 8 */
1912  if (modifiers & HLSL_STORAGE_VOLATILE)
1913  strcat(string, " volatile"); /* 9 */
1914  if (modifiers & HLSL_MODIFIER_CONST)
1915  strcat(string, " const"); /* 6 */
1916  if (modifiers & HLSL_MODIFIER_ROW_MAJOR)
1917  strcat(string, " row_major"); /* 10 */
1918  if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
1919  strcat(string, " column_major"); /* 13 */
1921  strcat(string, " inout"); /* 6 */
1922  else if (modifiers & HLSL_MODIFIER_IN)
1923  strcat(string, " in"); /* 3 */
1924  else if (modifiers & HLSL_MODIFIER_OUT)
1925  strcat(string, " out"); /* 4 */
1926 
1927  return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
1928 }
1929 
1930 static const char *debug_node_type(enum hlsl_ir_node_type type)
1931 {
1932  static const char * const names[] =
1933  {
1934  "HLSL_IR_VAR",
1935  "HLSL_IR_ASSIGNMENT",
1936  "HLSL_IR_CONSTANT",
1937  "HLSL_IR_CONSTRUCTOR",
1938  "HLSL_IR_DEREF",
1939  "HLSL_IR_EXPR",
1940  "HLSL_IR_FUNCTION_DECL",
1941  "HLSL_IR_IF",
1942  "HLSL_IR_JUMP",
1943  "HLSL_IR_SWIZZLE",
1944  };
1945 
1946  if (type >= ARRAY_SIZE(names))
1947  return "Unexpected node type";
1948  return names[type];
1949 }
1950 
1951 static void debug_dump_instr(const struct hlsl_ir_node *instr);
1952 
1953 static void debug_dump_instr_list(const struct list *list)
1954 {
1955  struct hlsl_ir_node *instr;
1956 
1958  {
1960  TRACE("\n");
1961  }
1962 }
1963 
1964 static void debug_dump_ir_var(const struct hlsl_ir_var *var)
1965 {
1966  if (var->modifiers)
1967  TRACE("%s ", debug_modifiers(var->modifiers));
1968  TRACE("%s %s", debug_hlsl_type(var->node.data_type), var->name);
1969  if (var->semantic)
1970  TRACE(" : %s", debugstr_a(var->semantic));
1971 }
1972 
1973 static void debug_dump_ir_deref(const struct hlsl_ir_deref *deref)
1974 {
1975  switch (deref->type)
1976  {
1977  case HLSL_IR_DEREF_VAR:
1978  TRACE("deref(");
1979  debug_dump_ir_var(deref->v.var);
1980  TRACE(")");
1981  break;
1982  case HLSL_IR_DEREF_ARRAY:
1983  debug_dump_instr(deref->v.array.array);
1984  TRACE("[");
1985  debug_dump_instr(deref->v.array.index);
1986  TRACE("]");
1987  break;
1988  case HLSL_IR_DEREF_RECORD:
1989  debug_dump_instr(deref->v.record.record);
1990  TRACE(".%s", debugstr_a(deref->v.record.field->name));
1991  break;
1992  }
1993 }
1994 
1996 {
1997  struct hlsl_type *type = constant->node.data_type;
1998  unsigned int x, y;
1999 
2000  if (type->dimy != 1)
2001  TRACE("{");
2002  for (y = 0; y < type->dimy; ++y)
2003  {
2004  if (type->dimx != 1)
2005  TRACE("{");
2006  for (x = 0; x < type->dimx; ++x)
2007  {
2008  switch (type->base_type)
2009  {
2010  case HLSL_TYPE_FLOAT:
2011  TRACE("%g ", (double)constant->v.value.f[y * type->dimx + x]);
2012  break;
2013  case HLSL_TYPE_DOUBLE:
2014  TRACE("%g ", constant->v.value.d[y * type->dimx + x]);
2015  break;
2016  case HLSL_TYPE_INT:
2017  TRACE("%d ", constant->v.value.i[y * type->dimx + x]);
2018  break;
2019  case HLSL_TYPE_UINT:
2020  TRACE("%u ", constant->v.value.u[y * type->dimx + x]);
2021  break;
2022  case HLSL_TYPE_BOOL:
2023  TRACE("%s ", constant->v.value.b[y * type->dimx + x] == FALSE ? "false" : "true");
2024  break;
2025  default:
2026  TRACE("Constants of type %s not supported\n", debug_base_type(type));
2027  }
2028  }
2029  if (type->dimx != 1)
2030  TRACE("}");
2031  }
2032  if (type->dimy != 1)
2033  TRACE("}");
2034 }
2035 
2036 static const char *debug_expr_op(const struct hlsl_ir_expr *expr)
2037 {
2038  static const char * const op_names[] =
2039  {
2040  "~",
2041  "!",
2042  "-",
2043  "abs",
2044  "sign",
2045  "rcp",
2046  "rsq",
2047  "sqrt",
2048  "nrm",
2049  "exp2",
2050  "log2",
2051 
2052  "cast",
2053 
2054  "fract",
2055 
2056  "sin",
2057  "cos",
2058  "sin_reduced",
2059  "cos_reduced",
2060 
2061  "dsx",
2062  "dsy",
2063 
2064  "sat",
2065 
2066  "pre++",
2067  "pre--",
2068  "post++",
2069  "post--",
2070 
2071  "+",
2072  "-",
2073  "*",
2074  "/",
2075 
2076  "%",
2077 
2078  "<",
2079  ">",
2080  "<=",
2081  ">=",
2082  "==",
2083  "!=",
2084 
2085  "&&",
2086  "||",
2087 
2088  "<<",
2089  ">>",
2090  "&",
2091  "|",
2092  "^",
2093 
2094  "dot",
2095  "crs",
2096  "min",
2097  "max",
2098 
2099  "pow",
2100 
2101  "lerp",
2102 
2103  ",",
2104  };
2105 
2106  if (expr->op == HLSL_IR_UNOP_CAST)
2107  return debug_hlsl_type(expr->node.data_type);
2108 
2109  return op_names[expr->op];
2110 }
2111 
2112 /* Dumps the expression in a prefix "operator (operands)" form */
2113 static void debug_dump_ir_expr(const struct hlsl_ir_expr *expr)
2114 {
2115  unsigned int i;
2116 
2117  TRACE("%s (", debug_expr_op(expr));
2118  for (i = 0; i < 3 && expr->operands[i]; ++i)
2119  {
2120  debug_dump_instr(expr->operands[i]);
2121  TRACE(" ");
2122  }
2123  TRACE(")");
2124 }
2125 
2126 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *constructor)
2127 {
2128  struct hlsl_ir_node *arg;
2129 
2130  TRACE("%s (", debug_hlsl_type(constructor->node.data_type));
2131  LIST_FOR_EACH_ENTRY(arg, constructor->arguments, struct hlsl_ir_node, entry)
2132  {
2134  TRACE(" ");
2135  }
2136  TRACE(")");
2137 }
2138 
2139 static const char *debug_writemask(DWORD writemask)
2140 {
2141  static const char components[] = {'x', 'y', 'z', 'w'};
2142  char string[5];
2143  unsigned int i = 0, pos = 0;
2144 
2145  assert(!(writemask & ~BWRITERSP_WRITEMASK_ALL));
2146 
2147  while (writemask)
2148  {
2149  if (writemask & 1)
2150  string[pos++] = components[i];
2151  writemask >>= 1;
2152  i++;
2153  }
2154  string[pos] = '\0';
2155  return wine_dbg_sprintf(".%s", string);
2156 }
2157 
2158 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign)
2159 {
2160  TRACE("= (");
2161  debug_dump_instr(assign->lhs);
2162  if (assign->writemask != BWRITERSP_WRITEMASK_ALL)
2163  TRACE("%s", debug_writemask(assign->writemask));
2164  TRACE(" ");
2165  debug_dump_instr(assign->rhs);
2166  TRACE(")");
2167 }
2168 
2170 {
2171  unsigned int i;
2172 
2173  debug_dump_instr(swizzle->val);
2174  TRACE(".");
2175  if (swizzle->val->data_type->dimy > 1)
2176  {
2177  for (i = 0; i < swizzle->node.data_type->dimx; ++i)
2178  TRACE("_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf);
2179  }
2180  else
2181  {
2182  static const char c[] = {'x', 'y', 'z', 'w'};
2183 
2184  for (i = 0; i < swizzle->node.data_type->dimx; ++i)
2185  TRACE("%c", c[(swizzle->swizzle >> i * 2) & 0x3]);
2186  }
2187 }
2188 
2189 static void debug_dump_ir_jump(const struct hlsl_ir_jump *jump)
2190 {
2191  switch (jump->type)
2192  {
2193  case HLSL_IR_JUMP_BREAK:
2194  TRACE("break");
2195  break;
2196  case HLSL_IR_JUMP_CONTINUE:
2197  TRACE("continue");
2198  break;
2199  case HLSL_IR_JUMP_DISCARD:
2200  TRACE("discard");
2201  break;
2202  case HLSL_IR_JUMP_RETURN:
2203  TRACE("return ");
2204  if (jump->return_value)
2206  TRACE(";");
2207  break;
2208  }
2209 }
2210 
2211 static void debug_dump_ir_if(const struct hlsl_ir_if *if_node)
2212 {
2213  TRACE("if (");
2214  debug_dump_instr(if_node->condition);
2215  TRACE(")\n{\n");
2217  TRACE("}\n");
2218  if (if_node->else_instrs)
2219  {
2220  TRACE("else\n{\n");
2222  TRACE("}\n");
2223  }
2224 }
2225 
2226 static void debug_dump_instr(const struct hlsl_ir_node *instr)
2227 {
2228  switch (instr->type)
2229  {
2230  case HLSL_IR_EXPR:
2232  break;
2233  case HLSL_IR_DEREF:
2235  break;
2236  case HLSL_IR_CONSTANT:
2238  break;
2239  case HLSL_IR_ASSIGNMENT:
2241  break;
2242  case HLSL_IR_SWIZZLE:
2244  break;
2245  case HLSL_IR_CONSTRUCTOR:
2247  break;
2248  case HLSL_IR_JUMP:
2250  break;
2251  case HLSL_IR_IF:
2253  break;
2254  default:
2255  TRACE("<No dump function for %s>", debug_node_type(instr->type));
2256  }
2257 }
2258 
2260 {
2261  struct hlsl_ir_var *param;
2262 
2263  TRACE("Dumping function %s.\n", debugstr_a(func->func->name));
2264  TRACE("Function parameters:\n");
2265  LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, node.entry)
2266  {
2268  TRACE("\n");
2269  }
2270  if (func->semantic)
2271  TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
2272  if (func->body)
2273  {
2274  debug_dump_instr_list(func->body);
2275  }
2276 }
2277 
2279 {
2280  struct hlsl_struct_field *field, *next_field;
2281 
2282  d3dcompiler_free((void *)type->name);
2283  if (type->type == HLSL_CLASS_STRUCT)
2284  {
2285  LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
2286  {
2287  d3dcompiler_free((void *)field->name);
2288  d3dcompiler_free((void *)field->semantic);
2290  }
2291  }
2293 }
2294 
2296 {
2297  struct hlsl_ir_node *node, *next_node;
2298 
2299  if (!list)
2300  return;
2302  free_instr(node);
2304 }
2305 
2307 {
2308  struct hlsl_type *type = constant->node.data_type;
2309  unsigned int i;
2310  struct hlsl_ir_constant *field, *next_field;
2311 
2312  switch (type->type)
2313  {
2314  case HLSL_CLASS_ARRAY:
2315  for (i = 0; i < type->e.array.elements_count; ++i)
2316  free_ir_constant(&constant->v.array_elements[i]);
2317  d3dcompiler_free(constant->v.array_elements);
2318  break;
2319  case HLSL_CLASS_STRUCT:
2320  LIST_FOR_EACH_ENTRY_SAFE(field, next_field, constant->v.struct_elements, struct hlsl_ir_constant, node.entry)
2322  break;
2323  default:
2324  break;
2325  }
2327 }
2328 
2329 static void free_ir_deref(struct hlsl_ir_deref *deref)
2330 {
2331  switch (deref->type)
2332  {
2333  case HLSL_IR_DEREF_VAR:
2334  /* Variables are shared among nodes in the tree. */
2335  break;
2336  case HLSL_IR_DEREF_ARRAY:
2337  free_instr(deref->v.array.array);
2338  free_instr(deref->v.array.index);
2339  break;
2340  case HLSL_IR_DEREF_RECORD:
2341  free_instr(deref->v.record.record);
2342  break;
2343  }
2344  d3dcompiler_free(deref);
2345 }
2346 
2348 {
2349  free_instr(swizzle->val);
2351 }
2352 
2353 static void free_ir_constructor(struct hlsl_ir_constructor *constructor)
2354 {
2355  free_instr_list(constructor->arguments);
2356  d3dcompiler_free(constructor);
2357 }
2358 
2359 static void free_ir_expr(struct hlsl_ir_expr *expr)
2360 {
2361  unsigned int i;
2362 
2363  for (i = 0; i < 3; ++i)
2364  {
2365  if (!expr->operands[i])
2366  break;
2367  free_instr(expr->operands[i]);
2368  }
2369  free_instr_list(expr->subexpressions);
2371 }
2372 
2373 static void free_ir_assignment(struct hlsl_ir_assignment *assignment)
2374 {
2375  free_instr(assignment->lhs);
2376  free_instr(assignment->rhs);
2377  d3dcompiler_free(assignment);
2378 }
2379 
2380 static void free_ir_if(struct hlsl_ir_if *if_node)
2381 {
2382  free_instr(if_node->condition);
2383  free_instr_list(if_node->then_instrs);
2384  free_instr_list(if_node->else_instrs);
2385  d3dcompiler_free(if_node);
2386 }
2387 
2388 static void free_ir_jump(struct hlsl_ir_jump *jump)
2389 {
2390  if (jump->type == HLSL_IR_JUMP_RETURN)
2391  free_instr(jump->return_value);
2392  d3dcompiler_free(jump);
2393 }
2394 
2396 {
2397  switch (node->type)
2398  {
2399  case HLSL_IR_VAR:
2400  /* These are freed later on from the scopes. */
2401  break;
2402  case HLSL_IR_CONSTANT:
2404  break;
2405  case HLSL_IR_DEREF:
2407  break;
2408  case HLSL_IR_SWIZZLE:
2410  break;
2411  case HLSL_IR_CONSTRUCTOR:
2413  break;
2414  case HLSL_IR_EXPR:
2416  break;
2417  case HLSL_IR_ASSIGNMENT:
2419  break;
2420  case HLSL_IR_IF:
2422  break;
2423  case HLSL_IR_JUMP:
2425  break;
2426  default:
2427  FIXME("Unsupported node type %s\n", debug_node_type(node->type));
2428  }
2429 }
2430 
2432 {
2433  d3dcompiler_free((void *)decl->semantic);
2435  free_instr_list(decl->body);
2436  d3dcompiler_free(decl);
2437 }
2438 
2440 {
2442 }
2443 
2445 {
2447  d3dcompiler_free((void *)func->name);
2449 }
2450 
2452 {
2454 }
2455 
2456 void add_function_decl(struct wine_rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, BOOL intrinsic)
2457 {
2458  struct hlsl_ir_function *func;
2459  struct wine_rb_entry *func_entry, *old_entry;
2460 
2461  func_entry = wine_rb_get(funcs, name);
2462  if (func_entry)
2463  {
2464  func = WINE_RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry);
2465  if (intrinsic != func->intrinsic)
2466  {
2467  if (intrinsic)
2468  {
2469  ERR("Redeclaring a user defined function as an intrinsic.\n");
2470  return;
2471  }
2472  TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name));
2473  func->intrinsic = intrinsic;
2476  }
2477  decl->func = func;
2478  if ((old_entry = wine_rb_get(&func->overloads, decl->parameters)))
2479  {
2480  struct hlsl_ir_function_decl *old_decl =
2481  WINE_RB_ENTRY_VALUE(old_entry, struct hlsl_ir_function_decl, entry);
2482 
2483  if (!decl->body)
2484  {
2485  free_function_decl(decl);
2487  return;
2488  }
2489  wine_rb_remove(&func->overloads, old_entry);
2490  free_function_decl(old_decl);
2491  }
2492  wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
2494  return;
2495  }
2496  func = d3dcompiler_alloc(sizeof(*func));
2497  func->name = name;
2499  decl->func = func;
2500  wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
2501  func->intrinsic = intrinsic;
2502  wine_rb_put(funcs, func->name, &func->entry);
2503 }
const char * semantic
#define BWRITERSP_WRITEMASK_1
struct wine_rb_entry entry
GLenum func
Definition: glext.h:6028
struct hlsl_ir_expr * hlsl_add(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1408
static int compare_function_decl_rb(const void *key, const struct wine_rb_entry *entry)
Definition: utils.c:1798
struct hlsl_scope * cur_scope
unsigned int dimx
#define BWRITERVS_SWIZZLE_SHIFT
#define vsnprintf
Definition: tif_win32.c:406
struct hlsl_ir_node node
void free_instr_list(struct list *list)
Definition: utils.c:2295
struct hlsl_ir_expr * hlsl_sub(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1421
#define max(a, b)
Definition: svc.c:63
static void free_ir_expr(struct hlsl_ir_expr *expr)
Definition: utils.c:2359
#define TRUE
Definition: types.h:120
static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle *swizzle)
Definition: utils.c:2169
static void * d3dcompiler_realloc(void *ptr, SIZE_T size)
static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
Definition: utils.c:1121
#define shift
Definition: input.c:1668
static void free_function(struct hlsl_ir_function *func)
Definition: utils.c:2444
hlsl_base_type
BOOL compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
Definition: utils.c:1010
static struct hlsl_ir_deref * deref_from_node(const struct hlsl_ir_node *node)
void skip_dword_unknown(const char **ptr, unsigned int count)
Definition: utils.c:513
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
const struct reg_reservation * reg_reservation
enum hlsl_type_class type
D3D_BLOB_PART
Definition: d3dcompiler.h:85
#define BWRITERSP_WRITEMASK_ALL
const char * debug_print_shift(DWORD shift)
Definition: utils.c:181
HRESULT hr
Definition: shlfolder.c:183
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
Definition: image.c:133
static const char * debug_expr_op(const struct hlsl_ir_expr *expr)
Definition: utils.c:2036
union constant::@229 value[4]
struct x86_inst instr
Definition: http.c:6587
static void read_dword(const char **ptr, DWORD *d)
#define HLSL_MODIFIER_CONST
struct list vars
static const char * debug_print_relarg(const struct shader_reg *reg)
Definition: utils.c:318
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static struct hlsl_ir_if * if_from_node(const struct hlsl_ir_node *node)
GLuint GLuint GLsizei count
Definition: gl.h:1545
enum hlsl_sampler_dim sampler_dim
struct hlsl_ir_node node
enum hlsl_ir_node_type type
static void free_ir_jump(struct hlsl_ir_jump *jump)
Definition: utils.c:2388
#define WARN(fmt,...)
Definition: debug.h:111
static struct hlsl_ir_constructor * constructor_from_node(const struct hlsl_ir_node *node)
struct hlsl_ir_node node
struct wine_rb_entry scope_entry
static struct hlsl_ir_constant * constant_from_node(const struct hlsl_ir_node *node)
static struct hlsl_ir_assignment * assignment_from_node(const struct hlsl_ir_node *node)
const char * debug_hlsl_type(const struct hlsl_type *type)
Definition: utils.c:1866
static BOOL d3dcompiler_free(void *ptr)
static void write_dword(char **ptr, DWORD d)
struct hlsl_ir_node * return_value
D3D_FL9_3_MAX_TEXTURE_REPEAT enum _D3D_SHADER_VARIABLE_CLASS D3D_SHADER_VARIABLE_CLASS
GLintptr offset
Definition: glext.h:5920
#define HLSL_MODIFIERS_COMPARISON_MASK
HRESULT dxbc_init(struct dxbc *dxbc, unsigned int size)
Definition: utils.c:560
enum _D3D_SHADER_VARIABLE_TYPE D3D_SHADER_VARIABLE_TYPE
static struct hlsl_ir_expr * expr_from_node(const struct hlsl_ir_node *node)
GLdouble GLdouble t
Definition: gl.h:2047
BOOL find_function(const char *name)
Definition: utils.c:855
#define D3DERR_INVALIDCALL
unsigned int components_count_type(struct hlsl_type *type)
Definition: utils.c:860
static void free_function_decl(struct hlsl_ir_function_decl *decl)
Definition: utils.c:2431
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
Definition: ecma_167.h:138
GLuint buffer
Definition: glext.h:5915
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
void add_function_decl(struct wine_rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, BOOL intrinsic)
Definition: utils.c:2456
static struct hlsl_type * expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2, struct source_location *loc)
Definition: utils.c:1187
#define HLSL_MODIFIER_PRECISE
const char * debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c)
Definition: utils.c:35
void * arg
Definition: msvc.h:12
const char * debug_print_dstmod(DWORD mod)
Definition: utils.c:156
#define BWRITERVS_SWIZZLE_Z
HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob)
Definition: utils.c:658
BOOL next_node(stream_t *stream, strbuf_t *buf)
Definition: stream.c:140
struct hlsl_ir_expr * hlsl_mul(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1369
union hlsl_ir_deref::@233 v
#define HLSL_MODIFIER_OUT
struct hlsl_ir_expr * hlsl_le(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1460
#define E_FAIL
Definition: ddrawi.h:102
void hlsl_report_message(const char *filename, DWORD line, DWORD column, enum hlsl_error_level level, const char *fmt,...) PRINTF_ATTR(5
Definition: match.c:390
static const char * debug_writemask(DWORD writemask)
Definition: utils.c:2139
enum hlsl_ir_jump_type type
struct hlsl_ir_expr * hlsl_lt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1434
Definition: query.h:86
static struct hlsl_ir_swizzle * swizzle_from_node(const struct hlsl_ir_node *node)
static void * d3dcompiler_alloc(SIZE_T size)
static UINT array_size
Definition: msctf.c:69
const char * debug_print_srcreg(const struct shader_reg *reg)
Definition: utils.c:340
BOOL pop_scope(struct hlsl_parse_ctx *ctx)
Definition: utils.c:1721
__WINE_SERVER_LIST_INLINE struct list * list_head(const struct list *list)
Definition: list.h:131
struct source_location loc
const char * wine_dbg_sprintf(const char *format,...)
Definition: compat.c:271
struct hlsl_ir_deref * new_var_deref(struct hlsl_ir_var *var)
Definition: utils.c:1512
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
GLuint GLuint * names
Definition: glext.h:11545
struct node node
void free_hlsl_type(struct hlsl_type *type)
Definition: utils.c:2278
const char * debug_print_srcmod(DWORD mod)
Definition: utils.c:131
#define TAG_DXBC
union hlsl_type::@231 e
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void free_declaration(struct hlsl_ir_var *decl)
Definition: utils.c:801
HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc)
Definition: utils.c:580
void free_instr(struct hlsl_ir_node *node)
Definition: utils.c:2395
GLenum GLint GLuint mask
Definition: glext.h:6028
void init_functions_tree(struct wine_rb_tree *funcs)
Definition: utils.c:1833
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
GLenum const GLfloat * params
Definition: glext.h:5645
#define HLSL_STORAGE_STATIC
static void free_ir_deref(struct hlsl_ir_deref *deref)
Definition: utils.c:2329
struct hlsl_type * get_type(struct hlsl_scope *scope, const char *name, BOOL recursive)
Definition: utils.c:844
unsigned int BOOL
Definition: ntddk_ex.h:94
#define MESSAGEBUFFER_INITIAL_SIZE
__WINE_SERVER_LIST_INLINE unsigned int list_count(const struct list *list)
Definition: list.h:155
int type
Definition: query.h:88
GLuint base
Definition: 3dtext.c:35
static BOOL convertible_data_type(struct hlsl_type *type)
Definition: utils.c:1005
#define WINE_D3DCOMPILER_TO_STR(x)
Definition: utils.c:33
#define HLSL_STORAGE_GROUPSHARED
static void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign)
Definition: utils.c:2158
#define HLSL_MODIFIER_ROW_MAJOR
struct hlsl_ir_var * get_variable(struct hlsl_scope *scope, const char *name)
Definition: utils.c:787
#define FIXME(fmt,...)
Definition: debug.h:110
static int compare_function_rb(const void *key, const struct wine_rb_entry *entry)
Definition: utils.c:1825
static PVOID ptr
Definition: dispmode.c:27
BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
Definition: utils.c:764
struct hlsl_type * new_array_type(struct hlsl_type *basic_type, unsigned int array_size)
Definition: utils.c:831
static void free_ir_assignment(struct hlsl_ir_assignment *assignment)
Definition: utils.c:2373
static int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry)
Definition: utils.c:1688
struct hlsl_ir_node * condition
smooth NULL
Definition: ftsmooth.c:416
#define HLSL_STORAGE_SHARED
char * va_list
Definition: acmsvcex.h:78
struct hlsl_ir_expr * hlsl_ge(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1473
static const char * debug_base_type(const struct hlsl_type *type)
Definition: utils.c:1838
void free_function_rb(struct wine_rb_entry *entry, void *context)
Definition: utils.c:2451
#define HLSL_STORAGE_EXTERN
struct hlsl_struct_field * field
static void debug_dump_instr_list(const struct list *list)
Definition: utils.c:1953
struct hlsl_ir_expr * hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1499
struct hlsl_scope * upper
static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hlsl_base_type t2)
Definition: utils.c:1155
static void debug_dump_ir_var(const struct hlsl_ir_var *var)
Definition: utils.c:1964
static void wine_rb_init(struct wine_rb_tree *tree, wine_rb_compare_func_t compare)
Definition: rbtree.h:179
struct hlsl_ir_node * operands[3]
static struct hlsl_ir_var * var_from_node(const struct hlsl_ir_node *node)
static void free_ir_constant(struct hlsl_ir_constant *constant)
Definition: utils.c:2306
struct dxbc_section * sections
hlsl_ir_node_type
static const char * debug_print_writemask(DWORD mask)
Definition: utils.c:261
static const char * debug_node_type(enum hlsl_ir_node_type type)
Definition: utils.c:1930
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
static char * d3dcompiler_strdup(const char *string)
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define d
Definition: ke_i.h:81
struct hlsl_ir_expr * new_cast(struct hlsl_ir_node *node, struct hlsl_type *type, struct source_location *loc)
Definition: utils.c:1355
Definition: cmds.c:130
const char * debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part)
Definition: utils.c:109
void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl *func)
Definition: utils.c:2259
Definition: parser.c:43
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:77
struct hlsl_ir_function_decl * new_func_decl(struct hlsl_type *return_type, struct list *parameters)
Definition: utils.c:1732
#define WINE_RB_ENTRY_VALUE(element, type, field)
Definition: rbtree.h:31
#define HLSL_MODIFIER_IN
hlsl_ir_expr_op
struct hlsl_type * data_type
GLfloat param
Definition: glext.h:5796
const GLubyte * c
Definition: glext.h:8905
static struct __wine_debug_functions funcs
Definition: debug.c:59
struct hlsl_type * type
static BOOL implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
Definition: utils.c:1064
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint left
Definition: glext.h:7726
WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler)
BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
Definition: utils.c:886
GLdouble GLdouble right
Definition: glext.h:10859
enum hlsl_base_type base_type
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
const char * name
static void debug_dump_ir_deref(const struct hlsl_ir_deref *deref)
Definition: utils.c:1973
#define HLSL_STORAGE_UNIFORM
struct list * elements
static void wine_rb_destroy(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
Definition: rbtree.h:198
GLenum GLenum GLuint components
Definition: glext.h:9620
struct hlsl_parse_ctx hlsl_ctx
Definition: hlsl.tab.c:87
int ret
#define BWRITERSP_WRITEMASK_3
static __inline const char * debugstr_an(const char *s, int n)
Definition: compat.h:47
static void debug_dump_ir_jump(const struct hlsl_ir_jump *jump)
Definition: utils.c:2189
HKEY key
Definition: reg.c:42
static const char * debug_print_swizzle(DWORD arg)
Definition: utils.c:277
#define BWRITERSP_WRITEMASK_2
uint32_t entry
Definition: isohybrid.c:63
struct list * else_instrs
HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3DBlob **blob)
Definition: blob.c:136
const char * debug_print_dstreg(const struct shader_reg *reg)
Definition: utils.c:333
struct list scope_entry
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *constructor)
Definition: utils.c:2126
Definition: _list.h:228
#define BWRITERVS_SWIZZLE_X
HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size)
Definition: utils.c:532
static void debug_dump_ir_constant(const struct hlsl_ir_constant *constant)
Definition: utils.c:1995
unsigned int modifiers
static void wine_rb_remove(struct wine_rb_tree *tree, struct wine_rb_entry *entry)
Definition: rbtree.h:283
const char * debug_print_opcode(DWORD opcode)
Definition: utils.c:419
hlsl_type_class
static const char * get_regname(const struct shader_reg *reg)
Definition: utils.c:205
const char * debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t)
Definition: utils.c:53
static int compare_param_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
Definition: utils.c:1749
#define ERR(fmt,...)
Definition: debug.h:109
static void free_ir_if(struct hlsl_ir_if *if_node)
Definition: utils.c:2380
struct hlsl_ir_expr * hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1486
#define BWRITERVS_NOSWIZZLE
ULONG_PTR SIZE_T
Definition: typedefs.h:78
static struct hlsl_ir_jump * jump_from_node(const struct hlsl_ir_node *node)
enum hlsl_ir_deref_type type
struct hlsl_ir_var * var
#define S_OK
Definition: intsafe.h:59
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
Definition: rbtree.h:35
#define ARRAY_SIZE(a)
Definition: main.h:24
#define HeapReAlloc
Definition: compat.h:393
struct list entry
static int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct wine_rb_entry *entry)
Definition: rbtree.h:215
#define HLSL_STORAGE_NOINTERPOLATION
#define min(a, b)
Definition: monoChain.cc:55
static void debug_dump_ir_if(const struct hlsl_ir_if *if_node)
Definition: utils.c:2211
#define HLSL_STORAGE_VOLATILE
static int reg
Definition: i386-dis.c:1275
struct list * then_instrs
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
struct hlsl_ir_expr * hlsl_gt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1447
static struct hlsl_ir_node * implicit_conversion(struct hlsl_ir_node *node, struct hlsl_type *type, struct source_location *loc)
Definition: utils.c:1280
static void debug_dump_instr(const struct hlsl_ir_node *instr)
Definition: utils.c:2226
struct hlsl_type::@231::@232 array
struct hlsl_ir_deref * new_record_deref(struct hlsl_ir_node *record, struct hlsl_struct_field *field)
Definition: utils.c:1528
#define msg(x)
Definition: auth_time.c:54
struct hlsl_type * clone_hlsl_type(struct hlsl_type *old)
Definition: utils.c:932
Definition: name.c:36
static struct wine_rb_entry * wine_rb_get(const struct wine_rb_tree *tree, const void *key)
Definition: rbtree.h:203
#define BWRITERSP_WRITEMASK_0
struct hlsl_ir_node * rhs
struct hlsl_ir_expr * new_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node **operands, struct source_location *loc)
Definition: utils.c:1298
void dxbc_destroy(struct dxbc *dxbc)
Definition: utils.c:651
struct hlsl_ir_node * lhs
__WINE_SERVER_LIST_INLINE struct list * list_next(const struct list *list, const struct list *elem)
Definition: list.h:115
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
void compilation_message(struct compilation_messages *msg, const char *fmt, va_list args)
Definition: utils.c:722
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
struct hlsl_ir_expr * hlsl_div(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1382
struct hlsl_ir_node node
unsigned int modifiers
GLuint GLenum swizzle
Definition: glext.h:9511
const char * debug_modifiers(DWORD modifiers)
Definition: utils.c:1893
UINT op
Definition: effect.c:223
const char * debug_print_comp(DWORD comp)
Definition: utils.c:404
static void free_ir_swizzle(struct hlsl_ir_swizzle *swizzle)
Definition: utils.c:2347
struct hlsl_ir_node * array
const char * name
static void write_dword_unknown(char **ptr, DWORD d)
Definition: utils.c:526
struct hlsl_ir_node node
#define LIST_ENTRY(type)
Definition: queue.h:175
struct hlsl_type * new_hlsl_type(const char *name, enum hlsl_type_class type_class, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
Definition: utils.c:809
static void debug_dump_ir_expr(const struct hlsl_ir_expr *expr)
Definition: utils.c:2113
#define BWRITERVS_SWIZZLE_Y
struct hlsl_ir_expr * hlsl_mod(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, struct source_location *loc)
Definition: utils.c:1395
static enum hlsl_ir_expr_op op_from_assignment(enum parse_assign_op op)
Definition: utils.c:1548
struct hlsl_ir_function * func
struct hlsl_ir_node * record
struct hlsl_ir_node * make_assignment(struct hlsl_ir_node *left, enum parse_assign_op assign_op, DWORD writemask, struct hlsl_ir_node *right)
Definition: utils.c:1568
Definition: dsound.c:943
#define HeapFree(x, y, z)
Definition: compat.h:394
struct wine_rb_tree types
void * object
Definition: jmemsys.h:48
#define BWRITERVS_SWIZZLE_W
struct hlsl_ir_node node
unsigned int dimy
static void free_ir_constructor(struct hlsl_ir_constructor *constructor)
Definition: utils.c:2353
WCHAR * name
Definition: name.c:40
Definition: path.c:42
static void free_function_decl_rb(struct wine_rb_entry *entry, void *context)
Definition: utils.c:2439
static int mod
Definition: i386-dis.c:1273
Definition: dlist.c:348
#define HLSL_MODIFIER_COLUMN_MAJOR
void push_scope(struct hlsl_parse_ctx *ctx)
Definition: utils.c:1704
GLuint const GLchar * name
Definition: glext.h:6031
char * tag
Definition: main.c:59