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