dlls/d3dcompiler_43/reflection.c

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