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