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