dlls/d3dcompiler_43/reflection.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  * Copyright 2010 Rico Schüller
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  */
  20
  21 #include "initguid.h"
  22 #include "d3dcompiler_private.h"
  23 #include "d3d10.h"
  24
  25 #if !D3D_COMPILER_VERSION
  26 #define ID3D11ShaderReflection ID3D10ShaderReflection
  27 #define ID3D11ShaderReflectionVtbl ID3D10ShaderReflectionVtbl
  28 #define ID3D11ShaderReflectionConstantBuffer ID3D10ShaderReflectionConstantBuffer
  29 #define ID3D11ShaderReflectionConstantBufferVtbl ID3D10ShaderReflectionConstantBufferVtbl
  30 #define ID3D11ShaderReflectionType ID3D10ShaderReflectionType
  31 #define ID3D11ShaderReflectionTypeVtbl ID3D10ShaderReflectionTypeVtbl
  32 #define ID3D11ShaderReflectionVariable ID3D10ShaderReflectionVariable
  33 #define ID3D11ShaderReflectionVariableVtbl ID3D10ShaderReflectionVariableVtbl
  34 #define IID_ID3D11ShaderReflection IID_ID3D10ShaderReflection
  35 #define D3D11_SHADER_BUFFER_DESC D3D10_SHADER_BUFFER_DESC
  36 #define D3D11_SHADER_DESC D3D10_SHADER_DESC
  37 #define D3D11_SHADER_INPUT_BIND_DESC D3D10_SHADER_INPUT_BIND_DESC
  38 #define D3D11_SHADER_TYPE_DESC D3D10_SHADER_TYPE_DESC
  39 #define D3D11_SHADER_VARIABLE_DESC D3D10_SHADER_VARIABLE_DESC
  40 #define D3D11_SIGNATURE_PARAMETER_DESC D3D10_SIGNATURE_PARAMETER_DESC
  41 #endif
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
  44
  45 enum D3DCOMPILER_SIGNATURE_ELEMENT_SIZE
  46 {
  47     D3DCOMPILER_SIGNATURE_ELEMENT_SIZE6 = 6,
  48     D3DCOMPILER_SIGNATURE_ELEMENT_SIZE7 = 7,
  49 };
  50
  51 #define D3DCOMPILER_SHADER_TARGET_VERSION_MASK 0xffff
  52 #define D3DCOMPILER_SHADER_TARGET_SHADERTYPE_MASK 0xffff0000
  53
  54 struct d3dcompiler_shader_signature
  55 {
  56     D3D11_SIGNATURE_PARAMETER_DESC *elements;
  57     unsigned int element_count;
  58     char *string_data;
  59 };
  60
  61 struct d3dcompiler_shader_reflection_type
  62 {
  63     ID3D11ShaderReflectionType ID3D11ShaderReflectionType_iface;
  64
  65     uint32_t id;
  66     struct wine_rb_entry entry;
  67
  68     struct d3dcompiler_shader_reflection *reflection;
  69
  70     D3D11_SHADER_TYPE_DESC desc;
  71     struct d3dcompiler_shader_reflection_type_member *members;
  72     char *name;
  73 };
  74
  75 struct d3dcompiler_shader_reflection_type_member
  76 {
  77     char *name;
  78     uint32_t offset;
  79     struct d3dcompiler_shader_reflection_type *type;
  80 };
  81
  82 struct d3dcompiler_shader_reflection_variable
  83 {
  84     ID3D11ShaderReflectionVariable ID3D11ShaderReflectionVariable_iface;
  85
  86     struct d3dcompiler_shader_reflection_constant_buffer *constant_buffer;
  87     struct d3dcompiler_shader_reflection_type *type;
  88
  89     char *name;
  90     UINT start_offset;
  91     UINT size;
  92     UINT flags;
  93     void *default_value;
  94 };
  95
  96 struct d3dcompiler_shader_reflection_constant_buffer
  97 {
  98     ID3D11ShaderReflectionConstantBuffer ID3D11ShaderReflectionConstantBuffer_iface;
  99
 100     struct d3dcompiler_shader_reflection *reflection;
 101
 102     char *name;
 103     D3D_CBUFFER_TYPE type;
 104     UINT variable_count;
 105     UINT size;
 106     UINT flags;
 107
 108     struct d3dcompiler_shader_reflection_variable *variables;
 109 };
 110
 111 enum D3DCOMPILER_REFLECTION_VERSION
 112 {
 113     D3DCOMPILER_REFLECTION_VERSION_D3D10,
 114     D3DCOMPILER_REFLECTION_VERSION_D3D11,
 115     D3DCOMPILER_REFLECTION_VERSION_D3D12,
 116 };
 117
 118 /* ID3D11ShaderReflection */
 119 struct d3dcompiler_shader_reflection
 120 {
 121     ID3D11ShaderReflection ID3D11ShaderReflection_iface;
 122     LONG refcount;
 123
 124     enum D3DCOMPILER_REFLECTION_VERSION interface_version;
 125
 126     uint32_t target;
 127     char *creator;
 128     UINT flags;
 129     UINT version;
 130     UINT bound_resource_count;
 131     UINT constant_buffer_count;
 132
 133     UINT mov_instruction_count;
 134     UINT conversion_instruction_count;
 135     UINT instruction_count;
 136     UINT emit_instruction_count;
 137     D3D_PRIMITIVE_TOPOLOGY gs_output_topology;
 138     UINT gs_max_output_vertex_count;
 139     D3D_PRIMITIVE input_primitive;
 140     UINT cut_instruction_count;
 141     UINT def_count;
 142     UINT dcl_count;
 143     UINT static_flow_control_count;
 144     UINT float_instruction_count;
 145     UINT temp_register_count;
 146     UINT int_instruction_count;
 147     UINT uint_instruction_count;
 148     UINT temp_array_count;
 149     UINT array_instruction_count;
 150     UINT texture_normal_instructions;
 151     UINT texture_load_instructions;
 152     UINT texture_comp_instructions;
 153     UINT texture_bias_instructions;
 154     UINT texture_gradient_instructions;
 155     UINT dynamic_flow_control_count;
 156     UINT macro_instruction_count;
 157     UINT c_control_points;
 158     D3D_TESSELLATOR_OUTPUT_PRIMITIVE hs_output_primitive;
 159     D3D_TESSELLATOR_PARTITIONING hs_partitioning;
 160     D3D_TESSELLATOR_DOMAIN tessellator_domain;
 161
 162     struct d3dcompiler_shader_signature *isgn;
 163     struct d3dcompiler_shader_signature *osgn;
 164     struct d3dcompiler_shader_signature *pcsg;
 165     char *resource_string;
 166     D3D12_SHADER_INPUT_BIND_DESC *bound_resources;
 167     struct d3dcompiler_shader_reflection_constant_buffer *constant_buffers;
 168     struct wine_rb_tree types;
 169 };
 170
 171 static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3dcompiler_shader_reflection *reflection, const char *data, uint32_t offset);
 172
 173 static const struct ID3D11ShaderReflectionConstantBufferVtbl d3dcompiler_shader_reflection_constant_buffer_vtbl;
 174 static const struct ID3D11ShaderReflectionVariableVtbl d3dcompiler_shader_reflection_variable_vtbl;
 175 static const struct ID3D11ShaderReflectionTypeVtbl d3dcompiler_shader_reflection_type_vtbl;
 176
 177 /* null objects - needed for invalid calls */
 178 static struct d3dcompiler_shader_reflection_constant_buffer null_constant_buffer =
 179 {
 180     {&d3dcompiler_shader_reflection_constant_buffer_vtbl},
 181 };
 182 static struct d3dcompiler_shader_reflection_type null_type =
 183 {
 184     {&d3dcompiler_shader_reflection_type_vtbl},
 185 };
 186 static struct d3dcompiler_shader_reflection_variable null_variable =
 187 {
 188     {&d3dcompiler_shader_reflection_variable_vtbl},
 189     &null_constant_buffer,
 190     &null_type
 191 };
 192
 193 static BOOL copy_name(const char *ptr, char **name)
 194 {
 195     size_t name_len;
 196
 197     if (!ptr) return TRUE;
 198
 199     name_len = strlen(ptr) + 1;
 200     if (name_len == 1)
 201     {
 202         return TRUE;
 203     }
 204
 205     *name = HeapAlloc(GetProcessHeap(), 0, name_len);
 206     if (!*name)
 207     {
 208         ERR("Failed to allocate name memory.\n");
 209         return FALSE;
 210     }
 211
 212     memcpy(*name, ptr, name_len);
 213
 214     return TRUE;
 215 }
 216
 217 static BOOL copy_value(const char *ptr, void **value, uint32_t size)
 218 {
 219     if (!ptr || !size) return TRUE;
 220
 221     *value = HeapAlloc(GetProcessHeap(), 0, size);
 222     if (!*value)
 223     {
 224         ERR("Failed to allocate value memory.\n");
 225         return FALSE;
 226     }
 227
 228     memcpy(*value, ptr, size);
 229
 230     return TRUE;
 231 }
 232
 233 static int d3dcompiler_shader_reflection_type_compare(const void *key, const struct wine_rb_entry *entry)
 234 {
 235     const struct d3dcompiler_shader_reflection_type *t = WINE_RB_ENTRY_VALUE(entry, const struct d3dcompiler_shader_reflection_type, entry);
 236     const uint32_t *id = key;
 237
 238     return *id - t->id;
 239 }
 240
 241 static void free_type_member(struct d3dcompiler_shader_reflection_type_member *member)
 242 {
 243     if (member)
 244     {
 245         HeapFree(GetProcessHeap(), 0, member->name);
 246     }
 247 }
 248
 249 static void d3dcompiler_shader_reflection_type_destroy(struct wine_rb_entry *entry, void *context)
 250 {
 251     struct d3dcompiler_shader_reflection_type *t = WINE_RB_ENTRY_VALUE(entry, struct d3dcompiler_shader_reflection_type, entry);
 252     unsigned int i;
 253
 254     TRACE("reflection type %p.\n", t);
 255
 256     if (t->members)
 257     {
 258         for (i = 0; i < t->desc.Members; ++i)
 259         {
 260             free_type_member(&t->members[i]);
 261         }
 262         HeapFree(GetProcessHeap(), 0, t->members);
 263     }
 264
 265     heap_free(t->name);
 266     HeapFree(GetProcessHeap(), 0, t);
 267 }
 268
 269 static void free_signature(struct d3dcompiler_shader_signature *sig)
 270 {
 271     TRACE("Free signature %p\n", sig);
 272
 273     HeapFree(GetProcessHeap(), 0, sig->elements);
 274     HeapFree(GetProcessHeap(), 0, sig->string_data);
 275 }
 276
 277 static void free_variable(struct d3dcompiler_shader_reflection_variable *var)
 278 {
 279     if (var)
 280     {
 281         HeapFree(GetProcessHeap(), 0, var->name);
 282         HeapFree(GetProcessHeap(), 0, var->default_value);
 283     }
 284 }
 285
 286 static void free_constant_buffer(struct d3dcompiler_shader_reflection_constant_buffer *cb)
 287 {
 288     if (cb->variables)
 289     {
 290         unsigned int i;
 291
 292         for (i = 0; i < cb->variable_count; ++i)
 293         {
 294             free_variable(&cb->variables[i]);
 295         }
 296         HeapFree(GetProcessHeap(), 0, cb->variables);
 297     }
 298
 299     HeapFree(GetProcessHeap(), 0, cb->name);
 300 }
 301
 302 static void reflection_cleanup(struct d3dcompiler_shader_reflection *ref)
 303 {
 304     TRACE("Cleanup %p\n", ref);
 305
 306     if (ref->isgn)
 307     {
 308         free_signature(ref->isgn);
 309         HeapFree(GetProcessHeap(), 0, ref->isgn);
 310     }
 311
 312     if (ref->osgn)
 313     {
 314         free_signature(ref->osgn);
 315         HeapFree(GetProcessHeap(), 0, ref->osgn);
 316     }
 317
 318     if (ref->pcsg)
 319     {
 320         free_signature(ref->pcsg);
 321         HeapFree(GetProcessHeap(), 0, ref->pcsg);
 322     }
 323
 324     if (ref->constant_buffers)
 325     {
 326         unsigned int i;
 327
 328         for (i = 0; i < ref->constant_buffer_count; ++i)
 329         {
 330             free_constant_buffer(&ref->constant_buffers[i]);
 331         }
 332     }
 333
 334     wine_rb_destroy(&ref->types, d3dcompiler_shader_reflection_type_destroy, NULL);
 335     HeapFree(GetProcessHeap(), 0, ref->constant_buffers);
 336     HeapFree(GetProcessHeap(), 0, ref->bound_resources);
 337     HeapFree(GetProcessHeap(), 0, ref->resource_string);
 338     HeapFree(GetProcessHeap(), 0, ref->creator);
 339 }
 340
 341 /* IUnknown methods */
 342
 343 static inline struct d3dcompiler_shader_reflection *impl_from_ID3D11ShaderReflection(ID3D11ShaderReflection *iface)
 344 {
 345     return CONTAINING_RECORD(iface, struct d3dcompiler_shader_reflection, ID3D11ShaderReflection_iface);
 346 }
 347
 348 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_QueryInterface(ID3D11ShaderReflection *iface, REFIID riid, void **object)
 349 {
 350     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 351
 352     if (IsEqualGUID(riid, &IID_ID3D11ShaderReflection)
 353             || IsEqualGUID(riid, &IID_IUnknown)
 354             || (D3D_COMPILER_VERSION >= 47 && IsEqualGUID(riid, &IID_ID3D12ShaderReflection)))
 355     {
 356         IUnknown_AddRef(iface);
 357         *object = iface;
 358         return S_OK;
 359     }
 360
 361     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 362
 363     *object = NULL;
 364     return E_NOINTERFACE;
 365 }
 366
 367 static ULONG STDMETHODCALLTYPE d3dcompiler_shader_reflection_AddRef(ID3D11ShaderReflection *iface)
 368 {
 369     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 370     ULONG refcount = InterlockedIncrement(&This->refcount);
 371
 372     TRACE("%p increasing refcount to %lu.\n", This, refcount);
 373
 374     return refcount;
 375 }
 376
 377 static ULONG STDMETHODCALLTYPE d3dcompiler_shader_reflection_Release(ID3D11ShaderReflection *iface)
 378 {
 379     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 380     ULONG refcount = InterlockedDecrement(&This->refcount);
 381
 382     TRACE("%p decreasing refcount to %lu.\n", This, refcount);
 383
 384     if (!refcount)
 385     {
 386         reflection_cleanup(This);
 387         HeapFree(GetProcessHeap(), 0, This);
 388     }
 389
 390     return refcount;
 391 }
 392
 393 /* ID3D11ShaderReflection methods */
 394
 395 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetDesc(ID3D11ShaderReflection *iface, D3D11_SHADER_DESC *desc)
 396 {
 397     struct d3dcompiler_shader_reflection *reflection = impl_from_ID3D11ShaderReflection(iface);
 398
 399     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
 400
 401     if (!desc)
 402     {
 403         WARN("Invalid argument specified\n");
 404         return E_FAIL;
 405     }
 406
 407     desc->Version = reflection->version;
 408     desc->Creator = reflection->creator;
 409     desc->Flags = reflection->flags;
 410     desc->ConstantBuffers = reflection->constant_buffer_count;
 411     desc->BoundResources = reflection->bound_resource_count;
 412     desc->InputParameters = reflection->isgn ? reflection->isgn->element_count : 0;
 413     desc->OutputParameters = reflection->osgn ? reflection->osgn->element_count : 0;
 414     desc->InstructionCount = reflection->instruction_count;
 415     desc->TempRegisterCount = reflection->temp_register_count;
 416     desc->TempArrayCount = reflection->temp_array_count;
 417     desc->DefCount = reflection->def_count;
 418     desc->DclCount = reflection->dcl_count;
 419     desc->TextureNormalInstructions = reflection->texture_normal_instructions;
 420     desc->TextureLoadInstructions = reflection->texture_load_instructions;
 421     desc->TextureCompInstructions = reflection->texture_comp_instructions;
 422     desc->TextureBiasInstructions = reflection->texture_bias_instructions;
 423     desc->TextureGradientInstructions = reflection->texture_gradient_instructions;
 424     desc->FloatInstructionCount = reflection->float_instruction_count;
 425     desc->IntInstructionCount = reflection->int_instruction_count;
 426     desc->UintInstructionCount = reflection->uint_instruction_count;
 427     desc->StaticFlowControlCount = reflection->static_flow_control_count;
 428     desc->DynamicFlowControlCount = reflection->dynamic_flow_control_count;
 429     desc->MacroInstructionCount = reflection->macro_instruction_count;
 430     desc->ArrayInstructionCount = reflection->array_instruction_count;
 431     desc->CutInstructionCount = reflection->cut_instruction_count;
 432     desc->EmitInstructionCount = reflection->emit_instruction_count;
 433     desc->GSOutputTopology = reflection->gs_output_topology;
 434     desc->GSMaxOutputVertexCount = reflection->gs_max_output_vertex_count;
 435 #if D3D_COMPILER_VERSION
 436     desc->InputPrimitive = reflection->input_primitive;
 437     desc->PatchConstantParameters = reflection->pcsg ? reflection->pcsg->element_count : 0;
 438     desc->cGSInstanceCount = 0;
 439     desc->cControlPoints = reflection->c_control_points;
 440     desc->HSOutputPrimitive = reflection->hs_output_primitive;
 441     desc->HSPartitioning = reflection->hs_partitioning;
 442     desc->TessellatorDomain = reflection->tessellator_domain;
 443     desc->cBarrierInstructions = 0;
 444     desc->cInterlockedInstructions = 0;
 445     desc->cTextureStoreInstructions = 0;
 446 #endif
 447
 448     return S_OK;
 449 }
 450
 451 static struct ID3D11ShaderReflectionConstantBuffer * STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetConstantBufferByIndex(
 452         ID3D11ShaderReflection *iface, UINT index)
 453 {
 454     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 455
 456     TRACE("iface %p, index %u\n", iface, index);
 457
 458     if (index >= This->constant_buffer_count)
 459     {
 460         WARN("Invalid argument specified\n");
 461         return &null_constant_buffer.ID3D11ShaderReflectionConstantBuffer_iface;
 462     }
 463
 464     return &This->constant_buffers[index].ID3D11ShaderReflectionConstantBuffer_iface;
 465 }
 466
 467 static struct ID3D11ShaderReflectionConstantBuffer * STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetConstantBufferByName(
 468         ID3D11ShaderReflection *iface, const char *name)
 469 {
 470     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 471     unsigned int i;
 472
 473     TRACE("iface %p, name %s\n", iface, debugstr_a(name));
 474
 475     if (!name)
 476     {
 477         WARN("Invalid argument specified\n");
 478         return &null_constant_buffer.ID3D11ShaderReflectionConstantBuffer_iface;
 479     }
 480
 481     for (i = 0; i < This->constant_buffer_count; ++i)
 482     {
 483         struct d3dcompiler_shader_reflection_constant_buffer *d = &This->constant_buffers[i];
 484
 485         if (!strcmp(d->name, name))
 486         {
 487             TRACE("Returning ID3D11ShaderReflectionConstantBuffer %p.\n", d);
 488             return &d->ID3D11ShaderReflectionConstantBuffer_iface;
 489         }
 490     }
 491
 492     WARN("Invalid name specified\n");
 493
 494     return &null_constant_buffer.ID3D11ShaderReflectionConstantBuffer_iface;
 495 }
 496
 497 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetResourceBindingDesc(
 498         ID3D11ShaderReflection *iface, UINT index, D3D11_SHADER_INPUT_BIND_DESC *desc)
 499 {
 500     struct d3dcompiler_shader_reflection *reflection = impl_from_ID3D11ShaderReflection(iface);
 501
 502     TRACE("iface %p, index %u, desc %p\n", iface, index, desc);
 503
 504     if (!desc || index >= reflection->bound_resource_count)
 505     {
 506         WARN("Invalid argument specified\n");
 507         return E_INVALIDARG;
 508     }
 509
 510     memcpy(desc, &reflection->bound_resources[index],
 511             reflection->interface_version == D3DCOMPILER_REFLECTION_VERSION_D3D12
 512             ? sizeof(D3D12_SHADER_INPUT_BIND_DESC) : sizeof(D3D11_SHADER_INPUT_BIND_DESC));
 513
 514     return S_OK;
 515 }
 516
 517 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetInputParameterDesc(
 518         ID3D11ShaderReflection *iface, UINT index, D3D11_SIGNATURE_PARAMETER_DESC *desc)
 519 {
 520     struct d3dcompiler_shader_reflection *reflection = impl_from_ID3D11ShaderReflection(iface);
 521
 522     TRACE("iface %p, index %u, desc %p\n", iface, index, desc);
 523
 524     if (!desc || !reflection->isgn || index >= reflection->isgn->element_count)
 525     {
 526         WARN("Invalid argument specified\n");
 527         return E_INVALIDARG;
 528     }
 529
 530     *desc = reflection->isgn->elements[index];
 531
 532     return S_OK;
 533 }
 534
 535 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetOutputParameterDesc(
 536         ID3D11ShaderReflection *iface, UINT index, D3D11_SIGNATURE_PARAMETER_DESC *desc)
 537 {
 538     struct d3dcompiler_shader_reflection *reflection = impl_from_ID3D11ShaderReflection(iface);
 539
 540     TRACE("iface %p, index %u, desc %p\n", iface, index, desc);
 541
 542     if (!desc || !reflection->osgn || index >= reflection->osgn->element_count)
 543     {
 544         WARN("Invalid argument specified\n");
 545         return E_INVALIDARG;
 546     }
 547
 548     *desc = reflection->osgn->elements[index];
 549
 550     return S_OK;
 551 }
 552
 553 #if D3D_COMPILER_VERSION
 554 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetPatchConstantParameterDesc(
 555         ID3D11ShaderReflection *iface, UINT index, D3D11_SIGNATURE_PARAMETER_DESC *desc)
 556 {
 557     struct d3dcompiler_shader_reflection *reflection = impl_from_ID3D11ShaderReflection(iface);
 558
 559     TRACE("iface %p, index %u, desc %p\n", iface, index, desc);
 560
 561     if (!desc || !reflection->pcsg || index >= reflection->pcsg->element_count)
 562     {
 563         WARN("Invalid argument specified\n");
 564         return E_INVALIDARG;
 565     }
 566
 567     *desc = reflection->pcsg->elements[index];
 568
 569     return S_OK;
 570 }
 571
 572 static struct ID3D11ShaderReflectionVariable * STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetVariableByName(
 573         ID3D11ShaderReflection *iface, const char *name)
 574 {
 575     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 576     unsigned int i, k;
 577
 578     TRACE("iface %p, name %s\n", iface, debugstr_a(name));
 579
 580     if (!name)
 581     {
 582         WARN("Invalid name specified\n");
 583         return &null_variable.ID3D11ShaderReflectionVariable_iface;
 584     }
 585
 586     for (i = 0; i < This->constant_buffer_count; ++i)
 587     {
 588         struct d3dcompiler_shader_reflection_constant_buffer *cb = &This->constant_buffers[i];
 589
 590         for (k = 0; k < cb->variable_count; ++k)
 591         {
 592             struct d3dcompiler_shader_reflection_variable *v = &cb->variables[k];
 593
 594             if (!strcmp(v->name, name))
 595             {
 596                 TRACE("Returning ID3D11ShaderReflectionVariable %p.\n", v);
 597                 return &v->ID3D11ShaderReflectionVariable_iface;
 598             }
 599         }
 600     }
 601
 602     WARN("Invalid name specified\n");
 603
 604     return &null_variable.ID3D11ShaderReflectionVariable_iface;
 605 }
 606
 607 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetResourceBindingDescByName(
 608         ID3D11ShaderReflection *iface, const char *name, D3D11_SHADER_INPUT_BIND_DESC *desc)
 609 {
 610     struct d3dcompiler_shader_reflection *reflection = impl_from_ID3D11ShaderReflection(iface);
 611     unsigned int i;
 612
 613     TRACE("iface %p, name %s, desc %p\n", iface, debugstr_a(name), desc);
 614
 615     if (!desc || !name)
 616     {
 617         WARN("Invalid argument specified\n");
 618         return E_INVALIDARG;
 619     }
 620
 621     for (i = 0; i < reflection->bound_resource_count; ++i)
 622     {
 623         D3D12_SHADER_INPUT_BIND_DESC *d = &reflection->bound_resources[i];
 624
 625         if (!strcmp(d->Name, name))
 626         {
 627             TRACE("Returning D3D11_SHADER_INPUT_BIND_DESC %p.\n", d);
 628             memcpy(desc, d, reflection->interface_version == D3DCOMPILER_REFLECTION_VERSION_D3D12
 629                     ? sizeof(D3D12_SHADER_INPUT_BIND_DESC) : sizeof(D3D11_SHADER_INPUT_BIND_DESC));
 630             return S_OK;
 631         }
 632     }
 633
 634     WARN("Invalid name specified\n");
 635
 636     return E_INVALIDARG;
 637 }
 638
 639 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetMovInstructionCount(
 640         ID3D11ShaderReflection *iface)
 641 {
 642     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 643
 644     TRACE("iface %p\n", iface);
 645
 646     return This->mov_instruction_count;
 647 }
 648
 649 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetMovcInstructionCount(
 650         ID3D11ShaderReflection *iface)
 651 {
 652     FIXME("iface %p stub!\n", iface);
 653
 654     return 0;
 655 }
 656
 657 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetConversionInstructionCount(
 658         ID3D11ShaderReflection *iface)
 659 {
 660     struct d3dcompiler_shader_reflection *This = impl_from_ID3D11ShaderReflection(iface);
 661
 662     TRACE("iface %p\n", iface);
 663
 664     return This->conversion_instruction_count;
 665 }
 666
 667 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetBitwiseInstructionCount(
 668         ID3D11ShaderReflection *iface)
 669 {
 670     FIXME("iface %p stub!\n", iface);
 671
 672     return 0;
 673 }
 674
 675 static D3D_PRIMITIVE STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetGSInputPrimitive(
 676         ID3D11ShaderReflection *iface)
 677 {
 678     FIXME("iface %p stub!\n", iface);
 679
 680     return 0;
 681 }
 682
 683 static BOOL STDMETHODCALLTYPE d3dcompiler_shader_reflection_IsSampleFrequencyShader(
 684         ID3D11ShaderReflection *iface)
 685 {
 686     FIXME("iface %p stub!\n", iface);
 687
 688     return FALSE;
 689 }
 690
 691 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetNumInterfaceSlots(
 692         ID3D11ShaderReflection *iface)
 693 {
 694     FIXME("iface %p stub!\n", iface);
 695
 696     return 0;
 697 }
 698
 699 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetMinFeatureLevel(
 700         ID3D11ShaderReflection *iface, D3D_FEATURE_LEVEL *level)
 701 {
 702     FIXME("iface %p, level %p stub!\n", iface, level);
 703
 704     return E_NOTIMPL;
 705 }
 706
 707 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetThreadGroupSize(
 708         ID3D11ShaderReflection *iface, UINT *sizex, UINT *sizey, UINT *sizez)
 709 {
 710     FIXME("iface %p, sizex %p, sizey %p, sizez %p stub!\n", iface, sizex, sizey, sizez);
 711
 712     return 0;
 713 }
 714
 715 static UINT64 STDMETHODCALLTYPE d3dcompiler_shader_reflection_GetRequiresFlags(
 716         ID3D11ShaderReflection *iface)
 717 {
 718     FIXME("iface %p stub!\n", iface);
 719
 720     return 0;
 721 }
 722 #endif
 723
 724 static const struct ID3D11ShaderReflectionVtbl d3dcompiler_shader_reflection_vtbl =
 725 {
 726     /* IUnknown methods */
 727     d3dcompiler_shader_reflection_QueryInterface,
 728     d3dcompiler_shader_reflection_AddRef,
 729     d3dcompiler_shader_reflection_Release,
 730     /* ID3D11ShaderReflection methods */
 731     d3dcompiler_shader_reflection_GetDesc,
 732     d3dcompiler_shader_reflection_GetConstantBufferByIndex,
 733     d3dcompiler_shader_reflection_GetConstantBufferByName,
 734     d3dcompiler_shader_reflection_GetResourceBindingDesc,
 735     d3dcompiler_shader_reflection_GetInputParameterDesc,
 736     d3dcompiler_shader_reflection_GetOutputParameterDesc,
 737 #if D3D_COMPILER_VERSION
 738     d3dcompiler_shader_reflection_GetPatchConstantParameterDesc,
 739     d3dcompiler_shader_reflection_GetVariableByName,
 740     d3dcompiler_shader_reflection_GetResourceBindingDescByName,
 741     d3dcompiler_shader_reflection_GetMovInstructionCount,
 742     d3dcompiler_shader_reflection_GetMovcInstructionCount,
 743     d3dcompiler_shader_reflection_GetConversionInstructionCount,
 744     d3dcompiler_shader_reflection_GetBitwiseInstructionCount,
 745     d3dcompiler_shader_reflection_GetGSInputPrimitive,
 746     d3dcompiler_shader_reflection_IsSampleFrequencyShader,
 747     d3dcompiler_shader_reflection_GetNumInterfaceSlots,
 748     d3dcompiler_shader_reflection_GetMinFeatureLevel,
 749     d3dcompiler_shader_reflection_GetThreadGroupSize,
 750     d3dcompiler_shader_reflection_GetRequiresFlags,
 751 #endif
 752 };
 753
 754 /* ID3D11ShaderReflectionConstantBuffer methods */
 755
 756 static inline struct d3dcompiler_shader_reflection_constant_buffer *impl_from_ID3D11ShaderReflectionConstantBuffer(ID3D11ShaderReflectionConstantBuffer *iface)
 757 {
 758     return CONTAINING_RECORD(iface, struct d3dcompiler_shader_reflection_constant_buffer, ID3D11ShaderReflectionConstantBuffer_iface);
 759 }
 760
 761 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_constant_buffer_GetDesc(
 762         ID3D11ShaderReflectionConstantBuffer *iface, D3D11_SHADER_BUFFER_DESC *desc)
 763 {
 764     struct d3dcompiler_shader_reflection_constant_buffer *This = impl_from_ID3D11ShaderReflectionConstantBuffer(iface);
 765
 766     TRACE("iface %p, desc %p\n", iface, desc);
 767
 768     if (This == &null_constant_buffer)
 769     {
 770         WARN("Null constant buffer specified\n");
 771         return E_FAIL;
 772     }
 773
 774     if (!desc)
 775     {
 776         WARN("Invalid argument specified\n");
 777         return E_FAIL;
 778     }
 779
 780     desc->Name = This->name;
 781     desc->Type = This->type;
 782     desc->Variables = This->variable_count;
 783     desc->Size = This->size;
 784     desc->uFlags = This->flags;
 785
 786     return S_OK;
 787 }
 788
 789 static ID3D11ShaderReflectionVariable * STDMETHODCALLTYPE d3dcompiler_shader_reflection_constant_buffer_GetVariableByIndex(
 790         ID3D11ShaderReflectionConstantBuffer *iface, UINT index)
 791 {
 792     struct d3dcompiler_shader_reflection_constant_buffer *This = impl_from_ID3D11ShaderReflectionConstantBuffer(iface);
 793
 794     TRACE("iface %p, index %u\n", iface, index);
 795
 796     if (index >= This->variable_count)
 797     {
 798         WARN("Invalid index specified\n");
 799         return &null_variable.ID3D11ShaderReflectionVariable_iface;
 800     }
 801
 802     return &This->variables[index].ID3D11ShaderReflectionVariable_iface;
 803 }
 804
 805 static ID3D11ShaderReflectionVariable * STDMETHODCALLTYPE d3dcompiler_shader_reflection_constant_buffer_GetVariableByName(
 806         ID3D11ShaderReflectionConstantBuffer *iface, const char *name)
 807 {
 808     struct d3dcompiler_shader_reflection_constant_buffer *This = impl_from_ID3D11ShaderReflectionConstantBuffer(iface);
 809     unsigned int i;
 810
 811     TRACE("iface %p, name %s\n", iface, debugstr_a(name));
 812
 813     if (!name)
 814     {
 815         WARN("Invalid argument specified\n");
 816         return &null_variable.ID3D11ShaderReflectionVariable_iface;
 817     }
 818
 819     for (i = 0; i < This->variable_count; ++i)
 820     {
 821         struct d3dcompiler_shader_reflection_variable *v = &This->variables[i];
 822
 823         if (!strcmp(v->name, name))
 824         {
 825             TRACE("Returning ID3D11ShaderReflectionVariable %p.\n", v);
 826             return &v->ID3D11ShaderReflectionVariable_iface;
 827         }
 828     }
 829
 830     WARN("Invalid name specified\n");
 831
 832     return &null_variable.ID3D11ShaderReflectionVariable_iface;
 833 }
 834
 835 static const struct ID3D11ShaderReflectionConstantBufferVtbl d3dcompiler_shader_reflection_constant_buffer_vtbl =
 836 {
 837     /* ID3D11ShaderReflectionConstantBuffer methods */
 838     d3dcompiler_shader_reflection_constant_buffer_GetDesc,
 839     d3dcompiler_shader_reflection_constant_buffer_GetVariableByIndex,
 840     d3dcompiler_shader_reflection_constant_buffer_GetVariableByName,
 841 };
 842
 843 /* ID3D11ShaderReflectionVariable methods */
 844
 845 static inline struct d3dcompiler_shader_reflection_variable *impl_from_ID3D11ShaderReflectionVariable(ID3D11ShaderReflectionVariable *iface)
 846 {
 847     return CONTAINING_RECORD(iface, struct d3dcompiler_shader_reflection_variable, ID3D11ShaderReflectionVariable_iface);
 848 }
 849
 850 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_variable_GetDesc(
 851         ID3D11ShaderReflectionVariable *iface, D3D11_SHADER_VARIABLE_DESC *desc)
 852 {
 853     struct d3dcompiler_shader_reflection_variable *This = impl_from_ID3D11ShaderReflectionVariable(iface);
 854
 855     TRACE("iface %p, desc %p\n", iface, desc);
 856
 857     if (This == &null_variable)
 858     {
 859         WARN("Null variable specified\n");
 860         return E_FAIL;
 861     }
 862
 863     if (!desc)
 864     {
 865         WARN("Invalid argument specified\n");
 866         return E_FAIL;
 867     }
 868
 869     desc->Name = This->name;
 870     desc->StartOffset = This->start_offset;
 871     desc->Size = This->size;
 872     desc->uFlags = This->flags;
 873     desc->DefaultValue = This->default_value;
 874
 875 #if D3D_COMPILER_VERSION
 876     /* TODO test and set proper values for texture. */
 877     desc->StartTexture = 0xffffffff;
 878     desc->TextureSize = 0;
 879     desc->StartSampler = 0xffffffff;
 880     desc->SamplerSize = 0;
 881 #endif
 882
 883     return S_OK;
 884 }
 885
 886 static ID3D11ShaderReflectionType * STDMETHODCALLTYPE d3dcompiler_shader_reflection_variable_GetType(
 887         ID3D11ShaderReflectionVariable *iface)
 888 {
 889     struct d3dcompiler_shader_reflection_variable *This = impl_from_ID3D11ShaderReflectionVariable(iface);
 890
 891     TRACE("iface %p\n", iface);
 892
 893     return &This->type->ID3D11ShaderReflectionType_iface;
 894 }
 895
 896 #if D3D_COMPILER_VERSION
 897 static ID3D11ShaderReflectionConstantBuffer * STDMETHODCALLTYPE d3dcompiler_shader_reflection_variable_GetBuffer(
 898         ID3D11ShaderReflectionVariable *iface)
 899 {
 900     struct d3dcompiler_shader_reflection_variable *This = impl_from_ID3D11ShaderReflectionVariable(iface);
 901
 902     TRACE("iface %p\n", iface);
 903
 904     return &This->constant_buffer->ID3D11ShaderReflectionConstantBuffer_iface;
 905 }
 906
 907 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_variable_GetInterfaceSlot(
 908         ID3D11ShaderReflectionVariable *iface, UINT index)
 909 {
 910     FIXME("iface %p, index %u stub!\n", iface, index);
 911
 912     return 0;
 913 }
 914 #endif
 915
 916 static const struct ID3D11ShaderReflectionVariableVtbl d3dcompiler_shader_reflection_variable_vtbl =
 917 {
 918     /* ID3D11ShaderReflectionVariable methods */
 919     d3dcompiler_shader_reflection_variable_GetDesc,
 920     d3dcompiler_shader_reflection_variable_GetType,
 921 #if D3D_COMPILER_VERSION
 922     d3dcompiler_shader_reflection_variable_GetBuffer,
 923     d3dcompiler_shader_reflection_variable_GetInterfaceSlot,
 924 #endif
 925 };
 926
 927 /* ID3D11ShaderReflectionType methods */
 928
 929 static inline struct d3dcompiler_shader_reflection_type *impl_from_ID3D11ShaderReflectionType(ID3D11ShaderReflectionType *iface)
 930 {
 931     return CONTAINING_RECORD(iface, struct d3dcompiler_shader_reflection_type, ID3D11ShaderReflectionType_iface);
 932 }
 933
 934 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetDesc(
 935         ID3D11ShaderReflectionType *iface, D3D11_SHADER_TYPE_DESC *desc)
 936 {
 937     struct d3dcompiler_shader_reflection_type *This = impl_from_ID3D11ShaderReflectionType(iface);
 938
 939     TRACE("iface %p, desc %p\n", iface, desc);
 940
 941     if (This == &null_type)
 942     {
 943         WARN("Null type specified\n");
 944         return E_FAIL;
 945     }
 946
 947     if (!desc)
 948     {
 949         WARN("Invalid argument specified\n");
 950         return E_FAIL;
 951     }
 952
 953     *desc = This->desc;
 954
 955     return S_OK;
 956 }
 957
 958 static ID3D11ShaderReflectionType * STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetMemberTypeByIndex(
 959         ID3D11ShaderReflectionType *iface, UINT index)
 960 {
 961     struct d3dcompiler_shader_reflection_type *This = impl_from_ID3D11ShaderReflectionType(iface);
 962
 963     TRACE("iface %p, index %u\n", iface, index);
 964
 965     if (index >= This->desc.Members)
 966     {
 967         WARN("Invalid index specified\n");
 968         return &null_type.ID3D11ShaderReflectionType_iface;
 969     }
 970
 971     return &This->members[index].type->ID3D11ShaderReflectionType_iface;
 972 }
 973
 974 static ID3D11ShaderReflectionType * STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetMemberTypeByName(
 975         ID3D11ShaderReflectionType *iface, const char *name)
 976 {
 977     struct d3dcompiler_shader_reflection_type *This = impl_from_ID3D11ShaderReflectionType(iface);
 978     unsigned int i;
 979
 980     TRACE("iface %p, name %s\n", iface, debugstr_a(name));
 981
 982     if (!name)
 983     {
 984         WARN("Invalid argument specified\n");
 985         return &null_type.ID3D11ShaderReflectionType_iface;
 986     }
 987
 988     for (i = 0; i < This->desc.Members; ++i)
 989     {
 990         struct d3dcompiler_shader_reflection_type_member *member = &This->members[i];
 991
 992         if (!strcmp(member->name, name))
 993         {
 994             TRACE("Returning ID3D11ShaderReflectionType %p.\n", member->type);
 995             return &member->type->ID3D11ShaderReflectionType_iface;
 996         }
 997     }
 998
 999     WARN("Invalid name specified\n");
1000
1001     return &null_type.ID3D11ShaderReflectionType_iface;
1002 }
1003
1004 static const char * STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetMemberTypeName(
1005         ID3D11ShaderReflectionType *iface, UINT index)
1006 {
1007     struct d3dcompiler_shader_reflection_type *This = impl_from_ID3D11ShaderReflectionType(iface);
1008
1009     TRACE("iface %p, index %u\n", iface, index);
1010
1011     if (This == &null_type)
1012     {
1013         WARN("Null type specified\n");
1014         return "$Invalid";
1015     }
1016
1017     if (index >= This->desc.Members)
1018     {
1019         WARN("Invalid index specified\n");
1020         return NULL;
1021     }
1022
1023     return This->members[index].name;
1024 }
1025
1026 #if D3D_COMPILER_VERSION
1027 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_IsEqual(
1028         ID3D11ShaderReflectionType *iface, ID3D11ShaderReflectionType *type)
1029 {
1030     struct d3dcompiler_shader_reflection_type *This = impl_from_ID3D11ShaderReflectionType(iface);
1031
1032     TRACE("iface %p, type %p\n", iface, type);
1033
1034     if (This == &null_type)
1035     {
1036         WARN("Null type specified\n");
1037         return E_FAIL;
1038     }
1039
1040     if (iface == type)
1041         return S_OK;
1042
1043     return S_FALSE;
1044 }
1045
1046 static ID3D11ShaderReflectionType * STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetSubType(
1047         ID3D11ShaderReflectionType *iface)
1048 {
1049     FIXME("iface %p stub!\n", iface);
1050
1051     return NULL;
1052 }
1053
1054 static ID3D11ShaderReflectionType * STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetBaseClass(
1055         ID3D11ShaderReflectionType *iface)
1056 {
1057     FIXME("iface %p stub!\n", iface);
1058
1059     return NULL;
1060 }
1061
1062 static UINT STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetNumInterfaces(
1063         ID3D11ShaderReflectionType *iface)
1064 {
1065     FIXME("iface %p stub!\n", iface);
1066
1067     return 0;
1068 }
1069
1070 static ID3D11ShaderReflectionType * STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_GetInterfaceByIndex(
1071         ID3D11ShaderReflectionType *iface, UINT index)
1072 {
1073     FIXME("iface %p, index %u stub!\n", iface, index);
1074
1075     return NULL;
1076 }
1077
1078 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_IsOfType(
1079         ID3D11ShaderReflectionType *iface, ID3D11ShaderReflectionType *type)
1080 {
1081     FIXME("iface %p, type %p stub!\n", iface, type);
1082
1083     return E_NOTIMPL;
1084 }
1085
1086 static HRESULT STDMETHODCALLTYPE d3dcompiler_shader_reflection_type_ImplementsInterface(
1087         ID3D11ShaderReflectionType *iface, ID3D11ShaderReflectionType *base)
1088 {
1089     FIXME("iface %p, base %p stub!\n", iface, base);
1090
1091     return E_NOTIMPL;
1092 }
1093 #endif
1094
1095 static const struct ID3D11ShaderReflectionTypeVtbl d3dcompiler_shader_reflection_type_vtbl =
1096 {
1097     /* ID3D11ShaderReflectionType methods */
1098     d3dcompiler_shader_reflection_type_GetDesc,
1099     d3dcompiler_shader_reflection_type_GetMemberTypeByIndex,
1100     d3dcompiler_shader_reflection_type_GetMemberTypeByName,
1101     d3dcompiler_shader_reflection_type_GetMemberTypeName,
1102 #if D3D_COMPILER_VERSION
1103     d3dcompiler_shader_reflection_type_IsEqual,
1104     d3dcompiler_shader_reflection_type_GetSubType,
1105     d3dcompiler_shader_reflection_type_GetBaseClass,
1106     d3dcompiler_shader_reflection_type_GetNumInterfaces,
1107     d3dcompiler_shader_reflection_type_GetInterfaceByIndex,
1108     d3dcompiler_shader_reflection_type_IsOfType,
1109     d3dcompiler_shader_reflection_type_ImplementsInterface,
1110 #endif
1111 };
1112
1113 static HRESULT d3dcompiler_parse_stat(struct d3dcompiler_shader_reflection *r, const char *data, size_t data_size)
1114 {
1115     const char *ptr = data;
1116     size_t size = data_size >> 2;
1117
1118     TRACE("Size %Iu.\n", size);
1119
1120     r->instruction_count = read_u32(&ptr);
1121     TRACE("InstructionCount: %u.\n", r->instruction_count);
1122
1123     r->temp_register_count = read_u32(&ptr);
1124     TRACE("TempRegisterCount: %u.\n", r->temp_register_count);
1125
1126     r->def_count = read_u32(&ptr);
1127     TRACE("DefCount: %u.\n", r->def_count);
1128
1129     r->dcl_count = read_u32(&ptr);
1130     TRACE("DclCount: %u.\n", r->dcl_count);
1131
1132     r->float_instruction_count = read_u32(&ptr);
1133     TRACE("FloatInstructionCount: %u.\n", r->float_instruction_count);
1134
1135     r->int_instruction_count = read_u32(&ptr);
1136     TRACE("IntInstructionCount: %u.\n", r->int_instruction_count);
1137
1138     r->uint_instruction_count = read_u32(&ptr);
1139     TRACE("UintInstructionCount: %u.\n", r->uint_instruction_count);
1140
1141     r->static_flow_control_count = read_u32(&ptr);
1142     TRACE("StaticFlowControlCount: %u.\n", r->static_flow_control_count);
1143
1144     r->dynamic_flow_control_count = read_u32(&ptr);
1145     TRACE("DynamicFlowControlCount: %u.\n", r->dynamic_flow_control_count);
1146
1147     r->macro_instruction_count = read_u32(&ptr);
1148     TRACE("MacroInstructionCount: %u.\n", r->macro_instruction_count);
1149
1150     r->temp_array_count = read_u32(&ptr);
1151     TRACE("TempArrayCount: %u.\n", r->temp_array_count);
1152
1153     r->array_instruction_count = read_u32(&ptr);
1154     TRACE("ArrayInstructionCount: %u.\n", r->array_instruction_count);
1155
1156     r->cut_instruction_count = read_u32(&ptr);
1157     TRACE("CutInstructionCount: %u.\n", r->cut_instruction_count);
1158
1159     r->emit_instruction_count = read_u32(&ptr);
1160     TRACE("EmitInstructionCount: %u.\n", r->emit_instruction_count);
1161
1162     r->texture_normal_instructions = read_u32(&ptr);
1163     TRACE("TextureNormalInstructions: %u.\n", r->texture_normal_instructions);
1164
1165     r->texture_load_instructions = read_u32(&ptr);
1166     TRACE("TextureLoadInstructions: %u.\n", r->texture_load_instructions);
1167
1168     r->texture_comp_instructions = read_u32(&ptr);
1169     TRACE("TextureCompInstructions: %u.\n", r->texture_comp_instructions);
1170
1171     r->texture_bias_instructions = read_u32(&ptr);
1172     TRACE("TextureBiasInstructions: %u.\n", r->texture_bias_instructions);
1173
1174     r->texture_gradient_instructions = read_u32(&ptr);
1175     TRACE("TextureGradientInstructions: %u.\n", r->texture_gradient_instructions);
1176
1177     r->mov_instruction_count = read_u32(&ptr);
1178     TRACE("MovInstructionCount: %u.\n", r->mov_instruction_count);
1179
1180     skip_u32_unknown(&ptr, 1);
1181
1182     r->conversion_instruction_count = read_u32(&ptr);
1183     TRACE("ConversionInstructionCount: %u.\n", r->conversion_instruction_count);
1184
1185     skip_u32_unknown(&ptr, 1);
1186
1187     r->input_primitive = read_u32(&ptr);
1188     TRACE("InputPrimitive: %x.\n", r->input_primitive);
1189
1190     r->gs_output_topology = read_u32(&ptr);
1191     TRACE("GSOutputTopology: %x.\n", r->gs_output_topology);
1192
1193     r->gs_max_output_vertex_count = read_u32(&ptr);
1194     TRACE("GSMaxOutputVertexCount: %u.\n", r->gs_max_output_vertex_count);
1195
1196     skip_u32_unknown(&ptr, 2);
1197
1198     /* old dx10 stat size */
1199     if (size == 28) return S_OK;
1200
1201     skip_u32_unknown(&ptr, 1);
1202
1203     /* dx10 stat size */
1204     if (size == 29) return S_OK;
1205
1206     skip_u32_unknown(&ptr, 1);
1207
1208     r->c_control_points = read_u32(&ptr);
1209     TRACE("cControlPoints: %u.\n", r->c_control_points);
1210
1211     r->hs_output_primitive = read_u32(&ptr);
1212     TRACE("HSOutputPrimitive: %x.\n", r->hs_output_primitive);
1213
1214     r->hs_partitioning = read_u32(&ptr);
1215     TRACE("HSPartitioning: %x.\n", r->hs_partitioning);
1216
1217     r->tessellator_domain = read_u32(&ptr);
1218     TRACE("TessellatorDomain: %x.\n", r->tessellator_domain);
1219
1220     skip_u32_unknown(&ptr, 3);
1221
1222     /* dx11 stat size */
1223     if (size == 37) return S_OK;
1224
1225     FIXME("Unhandled size %Iu.\n", size);
1226
1227     return E_FAIL;
1228 }
1229
1230 static HRESULT d3dcompiler_parse_type_members(struct d3dcompiler_shader_reflection *ref,
1231         struct d3dcompiler_shader_reflection_type_member *member, const char *data, const char **ptr)
1232 {
1233     uint32_t offset;
1234
1235     offset = read_u32(ptr);
1236     if (!copy_name(data + offset, &member->name))
1237     {
1238         ERR("Failed to copy name.\n");
1239         return E_OUTOFMEMORY;
1240     }
1241     TRACE("Member name: %s.\n", debugstr_a(member->name));
1242
1243     offset = read_u32(ptr);
1244     TRACE("Member type offset: %x.\n", offset);
1245
1246     member->type = get_reflection_type(ref, data, offset);
1247     if (!member->type)
1248     {
1249         ERR("Failed to get member type\n");
1250         HeapFree(GetProcessHeap(), 0, member->name);
1251         return E_FAIL;
1252     }
1253
1254     member->offset = read_u32(ptr);
1255     TRACE("Member offset %x.\n", member->offset);
1256
1257     return S_OK;
1258 }
1259
1260 static HRESULT d3dcompiler_parse_type(struct d3dcompiler_shader_reflection_type *type, const char *data, uint32_t offset)
1261 {
1262     const char *ptr = data + offset;
1263     uint32_t temp;
1264     D3D11_SHADER_TYPE_DESC *desc;
1265     unsigned int i;
1266     struct d3dcompiler_shader_reflection_type_member *members = NULL;
1267     HRESULT hr;
1268     uint32_t member_offset;
1269
1270     desc = &type->desc;
1271
1272     temp = read_u32(&ptr);
1273     desc->Class = temp & 0xffff;
1274     desc->Type = temp >> 16;
1275     TRACE("Class %s, Type %s\n", debug_d3dcompiler_shader_variable_class(desc->Class),
1276             debug_d3dcompiler_shader_variable_type(desc->Type));
1277
1278     temp = read_u32(&ptr);
1279     desc->Rows = temp & 0xffff;
1280     desc->Columns = temp >> 16;
1281     TRACE("Rows %u, Columns %u\n", desc->Rows, desc->Columns);
1282
1283     temp = read_u32(&ptr);
1284     desc->Elements = temp & 0xffff;
1285     desc->Members = temp >> 16;
1286     TRACE("Elements %u, Members %u\n", desc->Elements, desc->Members);
1287
1288     member_offset = read_u32(&ptr);
1289     TRACE("Member Offset %u.\n", member_offset);
1290
1291     if ((type->reflection->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK) >= 0x500)
1292         skip_u32_unknown(&ptr, 4);
1293
1294     if (desc->Members)
1295     {
1296         const char *ptr2 = data + member_offset;
1297
1298         members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*members) * desc->Members);
1299         if (!members)
1300         {
1301             ERR("Failed to allocate type memory.\n");
1302             return E_OUTOFMEMORY;
1303         }
1304
1305         for (i = 0; i < desc->Members; ++i)
1306         {
1307             hr = d3dcompiler_parse_type_members(type->reflection, &members[i], data, &ptr2);
1308             if (hr != S_OK)
1309             {
1310                 FIXME("Failed to parse type members.\n");
1311                 goto err_out;
1312             }
1313         }
1314     }
1315
1316 #if D3D_COMPILER_VERSION
1317     if ((type->reflection->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK) >= 0x500)
1318     {
1319         offset = read_u32(&ptr);
1320         if (!copy_name(data + offset, &type->name))
1321         {
1322             ERR("Failed to copy name.\n");
1323             heap_free(members);
1324             return E_OUTOFMEMORY;
1325         }
1326         desc->Name = type->name;
1327         TRACE("Type name: %s.\n", debugstr_a(type->name));
1328     }
1329 #endif
1330
1331     type->members = members;
1332
1333     return S_OK;
1334
1335 err_out:
1336     for (i = 0; i < desc->Members; ++i)
1337     {
1338         free_type_member(&members[i]);
1339     }
1340     HeapFree(GetProcessHeap(), 0, members);
1341     return hr;
1342 }
1343
1344 static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3dcompiler_shader_reflection *reflection, const char *data, uint32_t offset)
1345 {
1346     struct d3dcompiler_shader_reflection_type *type;
1347     struct wine_rb_entry *entry;
1348     HRESULT hr;
1349
1350     entry = wine_rb_get(&reflection->types, &offset);
1351     if (entry)
1352     {
1353         TRACE("Returning existing type.\n");
1354         return WINE_RB_ENTRY_VALUE(entry, struct d3dcompiler_shader_reflection_type, entry);
1355     }
1356
1357     type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*type));
1358     if (!type)
1359         return NULL;
1360
1361     type->ID3D11ShaderReflectionType_iface.lpVtbl = &d3dcompiler_shader_reflection_type_vtbl;
1362     type->id = offset;
1363     type->reflection = reflection;
1364
1365     hr = d3dcompiler_parse_type(type, data, offset);
1366     if (FAILED(hr))
1367     {
1368         ERR("Failed to parse type info, hr %#lx.\n", hr);
1369         HeapFree(GetProcessHeap(), 0, type);
1370         return NULL;
1371     }
1372
1373     if (wine_rb_put(&reflection->types, &offset, &type->entry) == -1)
1374     {
1375         ERR("Failed to insert type entry.\n");
1376         HeapFree(GetProcessHeap(), 0, type);
1377         return NULL;
1378     }
1379
1380     return type;
1381 }
1382
1383 static HRESULT d3dcompiler_parse_variables(struct d3dcompiler_shader_reflection_constant_buffer *cb,
1384         const char *data, size_t data_size, const char *ptr)
1385 {
1386     struct d3dcompiler_shader_reflection_variable *variables;
1387     unsigned int i;
1388     HRESULT hr;
1389
1390     variables = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cb->variable_count * sizeof(*variables));
1391     if (!variables)
1392     {
1393         ERR("Failed to allocate variables memory.\n");
1394         return E_OUTOFMEMORY;
1395     }
1396
1397     for (i = 0; i < cb->variable_count; i++)
1398     {
1399         struct d3dcompiler_shader_reflection_variable *v = &variables[i];
1400         uint32_t offset;
1401
1402         v->ID3D11ShaderReflectionVariable_iface.lpVtbl = &d3dcompiler_shader_reflection_variable_vtbl;
1403         v->constant_buffer = cb;
1404
1405         offset = read_u32(&ptr);
1406         if (!copy_name(data + offset, &v->name))
1407         {
1408             ERR("Failed to copy name.\n");
1409             hr = E_OUTOFMEMORY;
1410             goto err_out;
1411         }
1412         TRACE("Variable name: %s.\n", debugstr_a(v->name));
1413
1414         v->start_offset = read_u32(&ptr);
1415         TRACE("Variable offset: %u\n", v->start_offset);
1416
1417         v->size = read_u32(&ptr);
1418         TRACE("Variable size: %u\n", v->size);
1419
1420         v->flags = read_u32(&ptr);
1421         TRACE("Variable flags: %u\n", v->flags);
1422
1423         offset = read_u32(&ptr);
1424         TRACE("Variable type offset: %x.\n", offset);
1425         v->type = get_reflection_type(cb->reflection, data, offset);
1426         if (!v->type)
1427         {
1428             ERR("Failed to get type.\n");
1429             hr = E_FAIL;
1430             goto err_out;
1431         }
1432
1433         offset = read_u32(&ptr);
1434         TRACE("Variable default value offset: %x.\n", offset);
1435         if (!copy_value(data + offset, &v->default_value, offset ? v->size : 0))
1436         {
1437             ERR("Failed to copy name.\n");
1438             hr = E_OUTOFMEMORY;
1439             goto err_out;
1440         }
1441
1442         if ((cb->reflection->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK) >= 0x500)
1443             skip_u32_unknown(&ptr, 4);
1444     }
1445
1446     cb->variables = variables;
1447
1448     return S_OK;
1449
1450 err_out:
1451     for (i = 0; i < cb->variable_count; i++)
1452     {
1453         free_variable(&variables[i]);
1454     }
1455     HeapFree(GetProcessHeap(), 0, variables);
1456     return hr;
1457 }
1458
1459 static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, const char *data, size_t data_size)
1460 {
1461     struct d3dcompiler_shader_reflection_constant_buffer *constant_buffers = NULL;
1462     uint32_t offset, cbuffer_offset, resource_offset, creator_offset;
1463     unsigned int i, string_data_offset, string_data_size;
1464     D3D12_SHADER_INPUT_BIND_DESC *bound_resources = NULL;
1465     char *string_data = NULL, *creator = NULL;
1466     size_t size = data_size >> 2;
1467     uint32_t target_version;
1468     const char *ptr = data;
1469     HRESULT hr;
1470
1471     TRACE("Size %Iu.\n", size);
1472
1473     r->constant_buffer_count = read_u32(&ptr);
1474     TRACE("Constant buffer count: %u.\n", r->constant_buffer_count);
1475
1476     cbuffer_offset = read_u32(&ptr);
1477     TRACE("Constant buffer offset: %#x.\n", cbuffer_offset);
1478
1479     r->bound_resource_count = read_u32(&ptr);
1480     TRACE("Bound resource count: %u.\n", r->bound_resource_count);
1481
1482     resource_offset = read_u32(&ptr);
1483     TRACE("Bound resource offset: %#x.\n", resource_offset);
1484
1485     r->target = read_u32(&ptr);
1486     TRACE("Target: %#x.\n", r->target);
1487
1488     target_version = r->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK;
1489
1490 #if D3D_COMPILER_VERSION < 47
1491     if (target_version >= 0x501)
1492     {
1493         WARN("Target version %#x is not supported in d3dcompiler %u.\n", target_version, D3D_COMPILER_VERSION);
1494         return E_INVALIDARG;
1495     }
1496 #endif
1497
1498     r->flags = read_u32(&ptr);
1499     TRACE("Flags: %u.\n", r->flags);
1500
1501     creator_offset = read_u32(&ptr);
1502     TRACE("Creator at offset %#x.\n", creator_offset);
1503
1504     if (!copy_name(data + creator_offset, &creator))
1505     {
1506         ERR("Failed to copy name.\n");
1507         return E_OUTOFMEMORY;
1508     }
1509     TRACE("Creator: %s.\n", debugstr_a(creator));
1510
1511     /* todo: Parse RD11 */
1512     if (target_version >= 0x500)
1513     {
1514         skip_u32_unknown(&ptr, 8);
1515     }
1516
1517     if (r->bound_resource_count)
1518     {
1519         /* 8 for each bind desc */
1520         string_data_offset = resource_offset + r->bound_resource_count * 8 * sizeof(uint32_t);
1521         string_data_size = (cbuffer_offset ? cbuffer_offset : creator_offset) - string_data_offset;
1522
1523         string_data = HeapAlloc(GetProcessHeap(), 0, string_data_size);
1524         if (!string_data)
1525         {
1526             ERR("Failed to allocate string data memory.\n");
1527             hr = E_OUTOFMEMORY;
1528             goto err_out;
1529         }
1530         memcpy(string_data, data + string_data_offset, string_data_size);
1531
1532         bound_resources = HeapAlloc(GetProcessHeap(), 0, r->bound_resource_count * sizeof(*bound_resources));
1533         if (!bound_resources)
1534         {
1535             ERR("Failed to allocate resources memory.\n");
1536             hr = E_OUTOFMEMORY;
1537             goto err_out;
1538         }
1539
1540         ptr = data + resource_offset;
1541         for (i = 0; i < r->bound_resource_count; i++)
1542         {
1543             D3D12_SHADER_INPUT_BIND_DESC *desc = &bound_resources[i];
1544
1545             offset = read_u32(&ptr);
1546             desc->Name = string_data + (offset - string_data_offset);
1547             TRACE("Input bind Name: %s.\n", debugstr_a(desc->Name));
1548
1549             desc->Type = read_u32(&ptr);
1550             TRACE("Input bind Type: %#x.\n", desc->Type);
1551
1552             desc->ReturnType = read_u32(&ptr);
1553             TRACE("Input bind ReturnType: %#x.\n", desc->ReturnType);
1554
1555             desc->Dimension = read_u32(&ptr);
1556             TRACE("Input bind Dimension: %#x.\n", desc->Dimension);
1557
1558             desc->NumSamples = read_u32(&ptr);
1559             TRACE("Input bind NumSamples: %u.\n", desc->NumSamples);
1560
1561             desc->BindPoint = read_u32(&ptr);
1562             TRACE("Input bind BindPoint: %u.\n", desc->BindPoint);
1563
1564             desc->BindCount = read_u32(&ptr);
1565             TRACE("Input bind BindCount: %u.\n", desc->BindCount);
1566
1567             desc->uFlags = read_u32(&ptr);
1568             TRACE("Input bind uFlags: %u.\n", desc->uFlags);
1569
1570             if (target_version >= 0x501)
1571             {
1572                 desc->Space = read_u32(&ptr);
1573                 TRACE("Input bind Space %u.\n", desc->Space);
1574                 desc->uID = read_u32(&ptr);
1575                 TRACE("Input bind uID %u.\n", desc->uID);
1576             }
1577             else
1578             {
1579                 desc->Space = 0;
1580                 desc->uID = desc->BindPoint;
1581             }
1582         }
1583     }
1584
1585     if (r->constant_buffer_count)
1586     {
1587         constant_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, r->constant_buffer_count * sizeof(*constant_buffers));
1588         if (!constant_buffers)
1589         {
1590             ERR("Failed to allocate constant buffer memory.\n");
1591             hr = E_OUTOFMEMORY;
1592             goto err_out;
1593         }
1594
1595         ptr = data + cbuffer_offset;
1596         for (i = 0; i < r->constant_buffer_count; i++)
1597         {
1598             struct d3dcompiler_shader_reflection_constant_buffer *cb = &constant_buffers[i];
1599
1600             cb->ID3D11ShaderReflectionConstantBuffer_iface.lpVtbl = &d3dcompiler_shader_reflection_constant_buffer_vtbl;
1601             cb->reflection = r;
1602
1603             offset = read_u32(&ptr);
1604             if (!copy_name(data + offset, &cb->name))
1605             {
1606                 ERR("Failed to copy name.\n");
1607                 hr = E_OUTOFMEMORY;
1608                 goto err_out;
1609             }
1610             TRACE("Name: %s.\n", debugstr_a(cb->name));
1611
1612             cb->variable_count = read_u32(&ptr);
1613             TRACE("Variable count: %u.\n", cb->variable_count);
1614
1615             offset = read_u32(&ptr);
1616             TRACE("Variable offset: %x.\n", offset);
1617
1618             hr = d3dcompiler_parse_variables(cb, data, data_size, data + offset);
1619             if (hr != S_OK)
1620             {
1621                 FIXME("Failed to parse variables.\n");
1622                 goto err_out;
1623             }
1624
1625             cb->size = read_u32(&ptr);
1626             TRACE("Cbuffer size: %u.\n", cb->size);
1627
1628             cb->flags = read_u32(&ptr);
1629             TRACE("Cbuffer flags: %u.\n", cb->flags);
1630
1631             cb->type = read_u32(&ptr);
1632             TRACE("Cbuffer type: %#x.\n", cb->type);
1633         }
1634     }
1635
1636     r->creator = creator;
1637     r->resource_string = string_data;
1638     r->bound_resources = bound_resources;
1639     r->constant_buffers = constant_buffers;
1640
1641     return S_OK;
1642
1643 err_out:
1644     for (i = 0; i < r->constant_buffer_count; ++i)
1645     {
1646         free_constant_buffer(&constant_buffers[i]);
1647     }
1648     HeapFree(GetProcessHeap(), 0, constant_buffers);
1649     HeapFree(GetProcessHeap(), 0, bound_resources);
1650     HeapFree(GetProcessHeap(), 0, string_data);
1651     HeapFree(GetProcessHeap(), 0, creator);
1652
1653     return hr;
1654 }
1655
1656 static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature *s, struct dxbc_section *section)
1657 {
1658     enum D3DCOMPILER_SIGNATURE_ELEMENT_SIZE element_size;
1659     D3D11_SIGNATURE_PARAMETER_DESC *d;
1660     unsigned int string_data_offset;
1661     const char *ptr = section->data;
1662     unsigned int string_data_size;
1663     unsigned int i, count;
1664     char *string_data;
1665
1666     switch (section->tag)
1667     {
1668         case TAG_OSG5:
1669             element_size = D3DCOMPILER_SIGNATURE_ELEMENT_SIZE7;
1670             break;
1671
1672         case TAG_ISGN:
1673         case TAG_OSGN:
1674         case TAG_PCSG:
1675             element_size = D3DCOMPILER_SIGNATURE_ELEMENT_SIZE6;
1676             break;
1677
1678         default:
1679             FIXME("Unhandled section %s!\n", debugstr_an((const char *)&section->tag, 4));
1680             element_size = D3DCOMPILER_SIGNATURE_ELEMENT_SIZE6;
1681             break;
1682     }
1683
1684     count = read_u32(&ptr);
1685     TRACE("%u elements\n", count);
1686
1687     skip_u32_unknown(&ptr, 1);
1688
1689     d = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*d));
1690     if (!d)
1691     {
1692         ERR("Failed to allocate signature memory.\n");
1693         return E_OUTOFMEMORY;
1694     }
1695
1696     /* 2 u32s for the header, element_size for each element. */
1697     string_data_offset = 2 * sizeof(uint32_t) + count * element_size * sizeof(uint32_t);
1698     string_data_size = section->data_size - string_data_offset;
1699
1700     string_data = HeapAlloc(GetProcessHeap(), 0, string_data_size);
1701     if (!string_data)
1702     {
1703         ERR("Failed to allocate string data memory.\n");
1704         HeapFree(GetProcessHeap(), 0, d);
1705         return E_OUTOFMEMORY;
1706     }
1707     memcpy(string_data, section->data + string_data_offset, string_data_size);
1708
1709     for (i = 0; i < count; ++i)
1710     {
1711         uint32_t name_offset, mask;
1712
1713 #if D3D_COMPILER_VERSION >= 46
1714         /* FIXME */
1715         d[i].MinPrecision = D3D_MIN_PRECISION_DEFAULT;
1716 #endif
1717 #if D3D_COMPILER_VERSION
1718         if (element_size == D3DCOMPILER_SIGNATURE_ELEMENT_SIZE7)
1719         {
1720             d[i].Stream = read_u32(&ptr);
1721         }
1722         else
1723         {
1724             d[i].Stream = 0;
1725         }
1726 #endif
1727
1728         name_offset = read_u32(&ptr);
1729         d[i].SemanticName = string_data + (name_offset - string_data_offset);
1730         d[i].SemanticIndex = read_u32(&ptr);
1731         d[i].SystemValueType = read_u32(&ptr);
1732         d[i].ComponentType = read_u32(&ptr);
1733         d[i].Register = read_u32(&ptr);
1734         mask = read_u32(&ptr);
1735         d[i].ReadWriteMask = (mask >> 8) & 0xff;
1736         d[i].Mask = mask & 0xff;
1737
1738         if (!stricmp(d[i].SemanticName, "sv_depth"))
1739             d[i].SystemValueType = D3D_NAME_DEPTH;
1740         else if (!stricmp(d[i].SemanticName, "sv_coverage"))
1741             d[i].SystemValueType = D3D_NAME_COVERAGE;
1742         else if (!stricmp(d[i].SemanticName, "sv_depthgreaterequal"))
1743             d[i].SystemValueType = D3D_NAME_DEPTH_GREATER_EQUAL;
1744         else if (!stricmp(d[i].SemanticName, "sv_depthlessequal"))
1745             d[i].SystemValueType = D3D_NAME_DEPTH_LESS_EQUAL;
1746         else if (!stricmp(d[i].SemanticName, "sv_target"))
1747             d[i].SystemValueType = D3D_NAME_TARGET;
1748     }
1749
1750     s->elements = d;
1751     s->element_count = count;
1752     s->string_data = string_data;
1753
1754     return S_OK;
1755 }
1756
1757 static HRESULT d3dcompiler_parse_shdr(struct d3dcompiler_shader_reflection *r, const char *data, size_t data_size)
1758 {
1759     const char *ptr = data;
1760
1761     r->version = read_u32(&ptr);
1762     TRACE("Shader version: %u\n", r->version);
1763
1764     /* todo: Check if anything else is needed from the shdr or shex blob. */
1765
1766     return S_OK;
1767 }
1768
1769 static HRESULT d3dcompiler_shader_reflection_init(struct d3dcompiler_shader_reflection *reflection,
1770         const void *data, SIZE_T data_size)
1771 {
1772     struct dxbc src_dxbc;
1773     HRESULT hr;
1774     unsigned int i;
1775
1776     wine_rb_init(&reflection->types, d3dcompiler_shader_reflection_type_compare);
1777
1778     hr = dxbc_parse(data, data_size, &src_dxbc);
1779     if (FAILED(hr))
1780     {
1781         WARN("Failed to parse reflection\n");
1782         return hr;
1783     }
1784
1785     for (i = 0; i < src_dxbc.count; ++i)
1786     {
1787         struct dxbc_section *section = &src_dxbc.sections[i];
1788
1789         switch (section->tag)
1790         {
1791             case TAG_RDEF:
1792                 hr = d3dcompiler_parse_rdef(reflection, section->data, section->data_size);
1793                 if (FAILED(hr))
1794                 {
1795                     WARN("Failed to parse RDEF section.\n");
1796                     goto err_out;
1797                 }
1798                 break;
1799
1800             case TAG_ISGN:
1801                 reflection->isgn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*reflection->isgn));
1802                 if (!reflection->isgn)
1803                 {
1804                     ERR("Failed to allocate ISGN memory.\n");
1805                     hr = E_OUTOFMEMORY;
1806                     goto err_out;
1807                 }
1808
1809                 hr = d3dcompiler_parse_signature(reflection->isgn, section);
1810                 if (FAILED(hr))
1811                 {
1812                     WARN("Failed to parse section ISGN.\n");
1813                     goto err_out;
1814                 }
1815                 break;
1816
1817             case TAG_OSG5:
1818             case TAG_OSGN:
1819                 reflection->osgn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*reflection->osgn));
1820                 if (!reflection->osgn)
1821                 {
1822                     ERR("Failed to allocate OSGN memory.\n");
1823                     hr = E_OUTOFMEMORY;
1824                     goto err_out;
1825                 }
1826
1827                 hr = d3dcompiler_parse_signature(reflection->osgn, section);
1828                 if (FAILED(hr))
1829                 {
1830                     WARN("Failed to parse section OSGN.\n");
1831                     goto err_out;
1832                 }
1833                 break;
1834
1835             case TAG_PCSG:
1836                 reflection->pcsg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*reflection->pcsg));
1837                 if (!reflection->pcsg)
1838                 {
1839                     ERR("Failed to allocate PCSG memory.\n");
1840                     hr = E_OUTOFMEMORY;
1841                     goto err_out;
1842                 }
1843
1844                 hr = d3dcompiler_parse_signature(reflection->pcsg, section);
1845                 if (FAILED(hr))
1846                 {
1847                     WARN("Failed to parse section PCSG.\n");
1848                     goto err_out;
1849                 }
1850                 break;
1851
1852             case TAG_SHEX:
1853             case TAG_SHDR:
1854                 hr = d3dcompiler_parse_shdr(reflection, section->data, section->data_size);
1855                 if (FAILED(hr))
1856                 {
1857                     WARN("Failed to parse SHDR section.\n");
1858                     goto err_out;
1859                 }
1860                 break;
1861
1862             case TAG_STAT:
1863                 hr = d3dcompiler_parse_stat(reflection, section->data, section->data_size);
1864                 if (FAILED(hr))
1865                 {
1866                     WARN("Failed to parse section STAT.\n");
1867                     goto err_out;
1868                 }
1869                 break;
1870
1871             default:
1872                 FIXME("Unhandled section %s!\n", debugstr_an((const char *)&section->tag, 4));
1873                 break;
1874         }
1875     }
1876
1877     dxbc_destroy(&src_dxbc);
1878
1879     return hr;
1880
1881 err_out:
1882     reflection_cleanup(reflection);
1883     dxbc_destroy(&src_dxbc);
1884
1885     return hr;
1886 }
1887
1888 /* d3d10 reflection methods. */
1889 #if !D3D_COMPILER_VERSION
1890 HRESULT WINAPI D3D10ReflectShader(const void *data, SIZE_T data_size, ID3D10ShaderReflection **reflector)
1891 {
1892     struct d3dcompiler_shader_reflection *object;
1893     HRESULT hr;
1894
1895     TRACE("data %p, data_size %Iu, reflector %p.\n", data, data_size, reflector);
1896
1897     if (!(object = heap_alloc_zero(sizeof(*object))))
1898     {
1899         ERR("Failed to allocate D3D10 shader reflection object memory.\n");
1900         return E_OUTOFMEMORY;
1901     }
1902
1903     object->ID3D11ShaderReflection_iface.lpVtbl = &d3dcompiler_shader_reflection_vtbl;
1904     object->interface_version = D3DCOMPILER_REFLECTION_VERSION_D3D10;
1905     object->refcount = 1;
1906
1907     hr = d3dcompiler_shader_reflection_init(object, data, data_size);
1908     if (FAILED(hr))
1909     {
1910         WARN("Failed to initialize shader reflection.\n");
1911         HeapFree(GetProcessHeap(), 0, object);
1912         return hr;
1913     }
1914
1915     *reflector = (ID3D10ShaderReflection *)&object->ID3D11ShaderReflection_iface;
1916
1917     TRACE("Created ID3D10ShaderReflection %p.\n", object);
1918
1919     return S_OK;
1920 }
1921 #else
1922 HRESULT WINAPI D3DReflect(const void *data, SIZE_T data_size, REFIID riid, void **reflector)
1923 {
1924     struct d3dcompiler_shader_reflection *object;
1925     const uint32_t *temp = data;
1926     HRESULT hr;
1927
1928     TRACE("data %p, data_size %Iu, riid %s, blob %p.\n", data, data_size, debugstr_guid(riid), reflector);
1929
1930     if (!data || data_size < 32)
1931     {
1932         WARN("Invalid argument supplied.\n");
1933         return D3DERR_INVALIDCALL;
1934     }
1935
1936     if (temp[6] != data_size)
1937     {
1938         WARN("Wrong size supplied.\n");
1939 #if D3D_COMPILER_VERSION >= 46
1940         return D3DERR_INVALIDCALL;
1941 #else
1942         return E_FAIL;
1943 #endif
1944     }
1945
1946     if (!IsEqualGUID(riid, &IID_ID3D11ShaderReflection)
1947             && (D3D_COMPILER_VERSION < 47 || !IsEqualGUID(riid, &IID_ID3D12ShaderReflection)))
1948     {
1949         WARN("Wrong riid %s, accept only %s!\n", debugstr_guid(riid), debugstr_guid(&IID_ID3D11ShaderReflection));
1950 #if D3D_COMPILER_VERSION >= 46
1951         return E_INVALIDARG;
1952 #else
1953         return E_NOINTERFACE;
1954 #endif
1955     }
1956
1957     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1958     if (!object)
1959         return E_OUTOFMEMORY;
1960
1961     object->ID3D11ShaderReflection_iface.lpVtbl = &d3dcompiler_shader_reflection_vtbl;
1962     object->refcount = 1;
1963     object->interface_version = IsEqualGUID(riid, &IID_ID3D12ShaderReflection)
1964             ? D3DCOMPILER_REFLECTION_VERSION_D3D12 : D3DCOMPILER_REFLECTION_VERSION_D3D11;
1965
1966     hr = d3dcompiler_shader_reflection_init(object, data, data_size);
1967     if (FAILED(hr))
1968     {
1969         WARN("Failed to initialize shader reflection\n");
1970         HeapFree(GetProcessHeap(), 0, object);
1971         return hr;
1972     }
1973
1974     *reflector = object;
1975
1976     TRACE("Created ID3D11ShaderReflection %p\n", object);
1977
1978     return S_OK;
1979 }
1980 #endif