mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-21 10:25:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
5ea8b1692a
godot/thirdparty/spirv-reflect/spirv_reflect.c

4443 lines
148 KiB
C
Raw Blame History

/*
Copyright 2017-2018 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "spirv_reflect.h"
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#if defined(WIN32)
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#else
#include <stdlib.h>
#endif
// Temporary enums until these make it into SPIR-V/Vulkan
// clang-format off
enum {
SpvReflectOpDecorateId = 332,
SpvReflectOpDecorateStringGOOGLE = 5632,
SpvReflectOpMemberDecorateStringGOOGLE = 5633,
SpvReflectDecorationHlslCounterBufferGOOGLE = 5634,
SpvReflectDecorationHlslSemanticGOOGLE = 5635
};
// clang-format on
// clang-format off
enum {
SPIRV_STARTING_WORD_INDEX = 5,
SPIRV_WORD_SIZE = sizeof(uint32_t),
SPIRV_BYTE_WIDTH = 8,
SPIRV_MINIMUM_FILE_SIZE = SPIRV_STARTING_WORD_INDEX * SPIRV_WORD_SIZE,
SPIRV_DATA_ALIGNMENT = 4 * SPIRV_WORD_SIZE, // 16
SPIRV_ACCESS_CHAIN_INDEX_OFFSET = 4,
};
// clang-format on
// clang-format off
enum {
INVALID_VALUE = 0xFFFFFFFF,
};
// clang-format on
// clang-format off
enum {
MAX_NODE_NAME_LENGTH = 1024,
};
// clang-format on
// clang-format off
enum {
IMAGE_SAMPLED = 1,
IMAGE_STORAGE = 2
};
// clang-format on
// clang-format off
typedef struct ArrayTraits {
uint32_t element_type_id;
uint32_t length_id;
} ArrayTraits;
// clang-format on
// clang-format off
typedef struct ImageTraits {
uint32_t sampled_type_id;
SpvDim dim;
uint32_t depth;
uint32_t arrayed;
uint32_t ms;
uint32_t sampled;
SpvImageFormat image_format;
} ImageTraits;
// clang-format on
// clang-format off
typedef struct NumberDecoration {
uint32_t word_offset;
uint32_t value;
} NumberDecoration;
// clang-format on
// clang-format off
typedef struct StringDecoration {
uint32_t word_offset;
const char* value;
} StringDecoration;
// clang-format on
// clang-format off
typedef struct Decorations {
bool is_block;
bool is_buffer_block;
bool is_row_major;
bool is_column_major;
bool is_built_in;
bool is_noperspective;
bool is_flat;
bool is_non_writable;
NumberDecoration set;
NumberDecoration binding;
NumberDecoration input_attachment_index;
NumberDecoration location;
NumberDecoration offset;
NumberDecoration uav_counter_buffer;
StringDecoration semantic;
uint32_t array_stride;
uint32_t matrix_stride;
SpvBuiltIn built_in;
} Decorations;
// clang-format on
// clang-format off
typedef struct Node {
uint32_t result_id;
SpvOp op;
uint32_t result_type_id;
uint32_t type_id;
SpvStorageClass storage_class;
uint32_t word_offset;
uint32_t word_count;
bool is_type;
ArrayTraits array_traits;
ImageTraits image_traits;
uint32_t image_type_id;
const char* name;
Decorations decorations;
uint32_t member_count;
const char** member_names;
Decorations* member_decorations;
} Node;
// clang-format on
// clang-format off
typedef struct String {
uint32_t result_id;
const char* string;
} String;
// clang-format on
// clang-format off
typedef struct Function {
uint32_t id;
uint32_t callee_count;
uint32_t* callees;
struct Function** callee_ptrs;
uint32_t accessed_ptr_count;
uint32_t* accessed_ptrs;
} Function;
// clang-format on
// clang-format off
typedef struct AccessChain {
uint32_t result_id;
uint32_t result_type_id;
//
// Pointing to the base of a composite object.
// Generally the id of descriptor block variable
uint32_t base_id;
//
// From spec:
// The first index in Indexes will select the
// top-level member/element/component/element
// of the base composite
uint32_t index_count;
uint32_t* indexes;
} AccessChain;
// clang-format on
// clang-format off
typedef struct Parser {
size_t spirv_word_count;
uint32_t* spirv_code;
uint32_t string_count;
String* strings;
SpvSourceLanguage source_language;
uint32_t source_language_version;
uint32_t source_file_id;
String source_embedded;
size_t node_count;
Node* nodes;
uint32_t entry_point_count;
uint32_t function_count;
Function* functions;
uint32_t access_chain_count;
AccessChain* access_chains;
uint32_t type_count;
uint32_t descriptor_count;
uint32_t push_constant_count;
} Parser;
// clang-format on
static uint32_t Max(uint32_t a, uint32_t b)
{
return a > b ? a : b;
}
static uint32_t RoundUp(uint32_t value, uint32_t multiple)
{
assert(multiple && ((multiple & (multiple - 1)) == 0));
return (value + multiple - 1) & ~(multiple - 1);
}
#define IsNull(ptr) \
(ptr == NULL)
#define IsNotNull(ptr) \
(ptr != NULL)
#define SafeFree(ptr) \
{ \
if (ptr != NULL) { \
free((void*)ptr); \
ptr = NULL; \
} \
}
static int SortCompareUint32(const void* a, const void* b)
{
const uint32_t* p_a = (const uint32_t*)a;
const uint32_t* p_b = (const uint32_t*)b;
return (int)*p_a - (int)*p_b;
}
//
// De-duplicates a sorted array and returns the new size.
//
// Note: The array doesn't actually need to be sorted, just
// arranged into "runs" so that all the entries with one
// value are adjacent.
//
static size_t DedupSortedUint32(uint32_t* arr, size_t size)
{
if (size == 0) {
return 0;
}
size_t dedup_idx = 0;
for (size_t i = 0; i < size; ++i) {
if (arr[dedup_idx] != arr[i]) {
++dedup_idx;
arr[dedup_idx] = arr[i];
}
}
return dedup_idx+1;
}
static bool SearchSortedUint32(const uint32_t* arr, size_t size, uint32_t target)
{
size_t lo = 0;
size_t hi = size;
while (lo < hi) {
size_t mid = (hi - lo) / 2 + lo;
if (arr[mid] == target) {
return true;
} else if (arr[mid] < target) {
lo = mid+1;
} else {
hi = mid;
}
}
return false;
}
static SpvReflectResult IntersectSortedUint32(
const uint32_t* p_arr0,
size_t arr0_size,
const uint32_t* p_arr1,
size_t arr1_size,
uint32_t** pp_res,
size_t* res_size
)
{
*res_size = 0;
const uint32_t* arr0_end = p_arr0 + arr0_size;
const uint32_t* arr1_end = p_arr1 + arr1_size;
const uint32_t* idx0 = p_arr0;
const uint32_t* idx1 = p_arr1;
while (idx0 != arr0_end && idx1 != arr1_end) {
if (*idx0 < *idx1) {
++idx0;
} else if (*idx0 > *idx1) {
++idx1;
} else {
++*res_size;
++idx0;
++idx1;
}
}
*pp_res = NULL;
if (*res_size > 0) {
*pp_res = (uint32_t*)calloc(*res_size, sizeof(**pp_res));
if (IsNull(*pp_res)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
uint32_t* idxr = *pp_res;
idx0 = p_arr0;
idx1 = p_arr1;
while (idx0 != arr0_end && idx1 != arr1_end) {
if (*idx0 < *idx1) {
++idx0;
} else if (*idx0 > *idx1) {
++idx1;
} else {
*(idxr++) = *idx0;
++idx0;
++idx1;
}
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static bool InRange(const Parser* p_parser, uint32_t index)
{
bool in_range = false;
if (IsNotNull(p_parser)) {
in_range = (index < p_parser->spirv_word_count);
}
return in_range;
}
static SpvReflectResult ReadU32(Parser* p_parser, uint32_t word_offset, uint32_t* p_value)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
assert(InRange(p_parser, word_offset));
SpvReflectResult result = SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_EOF;
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && InRange(p_parser, word_offset)) {
*p_value = *(p_parser->spirv_code + word_offset);
result = SPV_REFLECT_RESULT_SUCCESS;
}
return result;
}
#define CHECKED_READU32(parser, word_offset, value) \
{ \
SpvReflectResult checked_readu32_result = ReadU32(parser, \
word_offset, (uint32_t*)&(value)); \
if (checked_readu32_result != SPV_REFLECT_RESULT_SUCCESS) { \
return checked_readu32_result; \
} \
}
#define CHECKED_READU32_CAST(parser, word_offset, cast_to_type, value) \
{ \
uint32_t checked_readu32_cast_u32 = UINT32_MAX; \
SpvReflectResult checked_readu32_cast_result = ReadU32(parser, \
word_offset, \
(uint32_t*)&(checked_readu32_cast_u32)); \
if (checked_readu32_cast_result != SPV_REFLECT_RESULT_SUCCESS) { \
return checked_readu32_cast_result; \
} \
value = (cast_to_type)checked_readu32_cast_u32; \
}
#define IF_READU32(result, parser, word_offset, value) \
if ((result) == SPV_REFLECT_RESULT_SUCCESS) { \
result = ReadU32(parser, word_offset, (uint32_t*)&(value)); \
}
#define IF_READU32_CAST(result, parser, word_offset, cast_to_type, value) \
if ((result) == SPV_REFLECT_RESULT_SUCCESS) { \
uint32_t if_readu32_cast_u32 = UINT32_MAX; \
result = ReadU32(parser, word_offset, &if_readu32_cast_u32); \
if ((result) == SPV_REFLECT_RESULT_SUCCESS) { \
value = (cast_to_type)if_readu32_cast_u32; \
} \
}
static SpvReflectResult ReadStr(
Parser* p_parser,
uint32_t word_offset,
uint32_t word_index,
uint32_t word_count,
uint32_t* p_buf_size,
char* p_buf
)
{
uint32_t limit = (word_offset + word_count);
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
assert(InRange(p_parser, limit));
SpvReflectResult result = SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_EOF;
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && InRange(p_parser, limit)) {
const char* c_str = (const char*)(p_parser->spirv_code + word_offset + word_index);
uint32_t n = word_count * SPIRV_WORD_SIZE;
uint32_t length_with_terminator = 0;
for (uint32_t i = 0; i < n; ++i) {
char c = *(c_str + i);
if (c == 0) {
length_with_terminator = i + 1;
break;
}
}
if (length_with_terminator > 0) {
result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
if (IsNotNull(p_buf_size) && IsNotNull(p_buf)) {
result = SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED;
if (length_with_terminator <= *p_buf_size) {
memset(p_buf, 0, *p_buf_size);
memcpy(p_buf, c_str, length_with_terminator);
result = SPV_REFLECT_RESULT_SUCCESS;
}
}
else {
if (IsNotNull(p_buf_size)) {
*p_buf_size = length_with_terminator;
result = SPV_REFLECT_RESULT_SUCCESS;
}
}
}
}
return result;
}
static SpvReflectDecorationFlags ApplyDecorations(const Decorations* p_decoration_fields)
{
SpvReflectDecorationFlags decorations = SPV_REFLECT_DECORATION_NONE;
if (p_decoration_fields->is_block) {
decorations |= SPV_REFLECT_DECORATION_BLOCK;
}
if (p_decoration_fields->is_buffer_block) {
decorations |= SPV_REFLECT_DECORATION_BUFFER_BLOCK;
}
if (p_decoration_fields->is_row_major) {
decorations |= SPV_REFLECT_DECORATION_ROW_MAJOR;
}
if (p_decoration_fields->is_column_major) {
decorations |= SPV_REFLECT_DECORATION_COLUMN_MAJOR;
}
if (p_decoration_fields->is_built_in) {
decorations |= SPV_REFLECT_DECORATION_BUILT_IN;
}
if (p_decoration_fields->is_noperspective) {
decorations |= SPV_REFLECT_DECORATION_NOPERSPECTIVE;
}
if (p_decoration_fields->is_flat) {
decorations |= SPV_REFLECT_DECORATION_FLAT;
}
if (p_decoration_fields->is_non_writable) {
decorations |= SPV_REFLECT_DECORATION_NON_WRITABLE;
}
return decorations;
}
static void ApplyNumericTraits(const SpvReflectTypeDescription* p_type, SpvReflectNumericTraits* p_numeric_traits)
{
memcpy(p_numeric_traits, &p_type->traits.numeric, sizeof(p_type->traits.numeric));
}
static void ApplyArrayTraits(const SpvReflectTypeDescription* p_type, SpvReflectArrayTraits* p_array_traits)
{
memcpy(p_array_traits, &p_type->traits.array, sizeof(p_type->traits.array));
}
static Node* FindNode(Parser* p_parser, uint32_t result_id)
{
Node* p_node = NULL;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_elem = &(p_parser->nodes[i]);
if (p_elem->result_id == result_id) {
p_node = p_elem;
break;
}
}
return p_node;
}
static SpvReflectTypeDescription* FindType(SpvReflectShaderModule* p_module, uint32_t type_id)
{
SpvReflectTypeDescription* p_type = NULL;
for (size_t i = 0; i < p_module->_internal->type_description_count; ++i) {
SpvReflectTypeDescription* p_elem = &(p_module->_internal->type_descriptions[i]);
if (p_elem->id == type_id) {
p_type = p_elem;
break;
}
}
return p_type;
}
static SpvReflectResult CreateParser(size_t size, void* p_code, Parser* p_parser)
{
if (p_code == NULL) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (size < SPIRV_MINIMUM_FILE_SIZE) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_CODE_SIZE;
}
if ((size % 4) != 0) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_CODE_SIZE;
}
p_parser->spirv_word_count = size / SPIRV_WORD_SIZE;
p_parser->spirv_code = (uint32_t*)p_code;
if (p_parser->spirv_code[0] != SpvMagicNumber) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_MAGIC_NUMBER;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static void DestroyParser(Parser* p_parser)
{
if (!IsNull(p_parser->nodes)) {
// Free nodes
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (IsNotNull(p_node->member_names)) {
SafeFree(p_node->member_names);
}
if (IsNotNull(p_node->member_decorations)) {
SafeFree(p_node->member_decorations);
}
}
// Free functions
for (size_t i = 0; i < p_parser->function_count; ++i) {
SafeFree(p_parser->functions[i].callees);
SafeFree(p_parser->functions[i].callee_ptrs);
SafeFree(p_parser->functions[i].accessed_ptrs);
}
// Free access chains
for (uint32_t i = 0; i < p_parser->access_chain_count; ++i) {
SafeFree(p_parser->access_chains[i].indexes);
}
SafeFree(p_parser->nodes);
SafeFree(p_parser->strings);
SafeFree(p_parser->functions);
SafeFree(p_parser->access_chains);
p_parser->node_count = 0;
}
}
static SpvReflectResult ParseNodes(Parser* p_parser)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
uint32_t* p_spirv = p_parser->spirv_code;
uint32_t spirv_word_index = SPIRV_STARTING_WORD_INDEX;
// Count nodes
uint32_t node_count = 0;
while (spirv_word_index < p_parser->spirv_word_count) {
uint32_t word = p_spirv[spirv_word_index];
SpvOp op = (SpvOp)(word & 0xFFFF);
uint32_t node_word_count = (word >> 16) & 0xFFFF;
if (node_word_count == 0) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_INSTRUCTION;
}
if (op == SpvOpAccessChain) {
++(p_parser->access_chain_count);
}
spirv_word_index += node_word_count;
++node_count;
}
if (node_count == 0) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_EOF;
}
// Allocate nodes
p_parser->node_count = node_count;
p_parser->nodes = (Node*)calloc(p_parser->node_count, sizeof(*(p_parser->nodes)));
if (IsNull(p_parser->nodes)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
// Mark all nodes with an invalid state
for (uint32_t i = 0; i < node_count; ++i) {
p_parser->nodes[i].op = (SpvOp)INVALID_VALUE;
p_parser->nodes[i].storage_class = (SpvStorageClass)INVALID_VALUE;
p_parser->nodes[i].decorations.set.value = (uint32_t)INVALID_VALUE;
p_parser->nodes[i].decorations.binding.value = (uint32_t)INVALID_VALUE;
p_parser->nodes[i].decorations.location.value = (uint32_t)INVALID_VALUE;
p_parser->nodes[i].decorations.offset.value = (uint32_t)INVALID_VALUE;
p_parser->nodes[i].decorations.uav_counter_buffer.value = (uint32_t)INVALID_VALUE;
p_parser->nodes[i].decorations.built_in = (SpvBuiltIn)INVALID_VALUE;
}
// Mark source file id node
p_parser->source_file_id = (uint32_t)INVALID_VALUE;
// Function node
uint32_t function_node = (uint32_t)INVALID_VALUE;
// Allocate access chain
if (p_parser->access_chain_count > 0) {
p_parser->access_chains = (AccessChain*)calloc(p_parser->access_chain_count, sizeof(*(p_parser->access_chains)));
if (IsNull(p_parser->access_chains)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
// Parse nodes
uint32_t node_index = 0;
uint32_t access_chain_index = 0;
spirv_word_index = SPIRV_STARTING_WORD_INDEX;
while (spirv_word_index < p_parser->spirv_word_count) {
uint32_t word = p_spirv[spirv_word_index];
SpvOp op = (SpvOp)(word & 0xFFFF);
uint32_t node_word_count = (word >> 16) & 0xFFFF;
Node* p_node = &(p_parser->nodes[node_index]);
p_node->op = op;
p_node->word_offset = spirv_word_index;
p_node->word_count = node_word_count;
switch (p_node->op) {
default: break;
case SpvOpString: {
++(p_parser->string_count);
}
break;
case SpvOpSource: {
CHECKED_READU32_CAST(p_parser, p_node->word_offset + 1, SpvSourceLanguage, p_parser->source_language);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_parser->source_language_version);
if (p_node->word_count >= 4) {
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_parser->source_file_id);
}
}
break;
case SpvOpEntryPoint: {
++(p_parser->entry_point_count);
}
break;
case SpvOpName:
case SpvOpMemberName:
{
uint32_t member_offset = (p_node->op == SpvOpMemberName) ? 1 : 0;
uint32_t name_start = p_node->word_offset + member_offset + 2;
p_node->name = (const char*)(p_parser->spirv_code + name_start);
}
break;
case SpvOpTypeStruct:
{
p_node->member_count = p_node->word_count - 2;
} // Fall through
case SpvOpTypeVoid:
case SpvOpTypeBool:
case SpvOpTypeInt:
case SpvOpTypeFloat:
case SpvOpTypeVector:
case SpvOpTypeMatrix:
case SpvOpTypeSampler:
case SpvOpTypeOpaque:
case SpvOpTypeFunction:
case SpvOpTypeEvent:
case SpvOpTypeDeviceEvent:
case SpvOpTypeReserveId:
case SpvOpTypeQueue:
case SpvOpTypePipe:
{
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
p_node->is_type = true;
}
break;
case SpvOpTypeImage: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->image_traits.sampled_type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->image_traits.dim);
CHECKED_READU32(p_parser, p_node->word_offset + 4, p_node->image_traits.depth);
CHECKED_READU32(p_parser, p_node->word_offset + 5, p_node->image_traits.arrayed);
CHECKED_READU32(p_parser, p_node->word_offset + 6, p_node->image_traits.ms);
CHECKED_READU32(p_parser, p_node->word_offset + 7, p_node->image_traits.sampled);
CHECKED_READU32(p_parser, p_node->word_offset + 8, p_node->image_traits.image_format);
p_node->is_type = true;
}
break;
case SpvOpTypeSampledImage: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->image_type_id);
p_node->is_type = true;
}
break;
case SpvOpTypeArray: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->array_traits.element_type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->array_traits.length_id);
p_node->is_type = true;
}
break;
case SpvOpTypeRuntimeArray: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->array_traits.element_type_id);
p_node->is_type = true;
}
break;
case SpvOpTypePointer: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->storage_class);
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->type_id);
p_node->is_type = true;
}
break;
case SpvOpTypeForwardPointer:
{
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->storage_class);
p_node->is_type = true;
}
break;
case SpvOpConstantTrue:
case SpvOpConstantFalse:
case SpvOpConstant:
case SpvOpConstantComposite:
case SpvOpConstantSampler:
case SpvOpConstantNull: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
}
break;
case SpvOpSpecConstantTrue:
case SpvOpSpecConstantFalse:
case SpvOpSpecConstant:
case SpvOpSpecConstantComposite:
case SpvOpSpecConstantOp: {
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
}
break;
case SpvOpVariable:
{
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->storage_class);
}
break;
case SpvOpLoad:
{
// Only load enough so OpDecorate can reference the node, skip the remaining operands.
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
}
break;
case SpvOpAccessChain:
{
AccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_access_chain->result_type_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_access_chain->result_id);
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_access_chain->base_id);
//
// SPIRV_ACCESS_CHAIN_INDEX_OFFSET (4) is the number of words up until the first index:
// [Node, Result Type Id, Result Id, Base Id, <Indexes>]
//
p_access_chain->index_count = (node_word_count - SPIRV_ACCESS_CHAIN_INDEX_OFFSET);
if (p_access_chain->index_count > 0) {
p_access_chain->indexes = (uint32_t*)calloc(p_access_chain->index_count, sizeof(*(p_access_chain->indexes)));
if (IsNull( p_access_chain->indexes)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
// Parse any index values for access chain
for (uint32_t index_index = 0; index_index < p_access_chain->index_count; ++index_index) {
// Read index id
uint32_t index_id = 0;
CHECKED_READU32(p_parser, p_node->word_offset + SPIRV_ACCESS_CHAIN_INDEX_OFFSET + index_index, index_id);
// Find OpConstant node that contains index value
Node* p_index_value_node = FindNode(p_parser, index_id);
if ((p_index_value_node != NULL) && (p_index_value_node->op == SpvOpConstant)) {
// Read index value
uint32_t index_value = UINT32_MAX;
CHECKED_READU32(p_parser, p_index_value_node->word_offset + 3, index_value);
assert(index_value != UINT32_MAX);
// Write index value to array
p_access_chain->indexes[index_index] = index_value;
}
}
}
++access_chain_index;
}
break;
case SpvOpFunction:
{
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
// Count function definitions, not function declarations. To determine
// the difference, set an in-function variable, and then if an OpLabel
// is reached before the end of the function increment the function
// count.
function_node = node_index;
}
break;
case SpvOpLabel:
{
if (function_node != (uint32_t)INVALID_VALUE) {
Node* p_func_node = &(p_parser->nodes[function_node]);
CHECKED_READU32(p_parser, p_func_node->word_offset + 2, p_func_node->result_id);
++(p_parser->function_count);
}
} // Fall through
case SpvOpFunctionEnd:
{
function_node = (uint32_t)INVALID_VALUE;
}
break;
}
if (p_node->is_type) {
++(p_parser->type_count);
}
spirv_word_index += node_word_count;
++node_index;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseStrings(Parser* p_parser)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
assert(IsNotNull(p_parser->nodes));
// Early out
if (p_parser->string_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
// Allocate string storage
p_parser->strings = (String*)calloc(p_parser->string_count, sizeof(*(p_parser->strings)));
uint32_t string_index = 0;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (p_node->op != SpvOpString) {
continue;
}
// Paranoid check against string count
assert(string_index < p_parser->string_count);
if (string_index >= p_parser->string_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
// Result id
String* p_string = &(p_parser->strings[string_index]);
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_string->result_id);
// String
uint32_t string_start = p_node->word_offset + 2;
p_string->string = (const char*)(p_parser->spirv_code + string_start);
// Increment string index
++string_index;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseSource(Parser* p_parser, SpvReflectShaderModule* p_module)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code)) {
// Source file
if (IsNotNull(p_parser->strings)) {
for (uint32_t i = 0; i < p_parser->string_count; ++i) {
String* p_string = &(p_parser->strings[i]);
if (p_string->result_id == p_parser->source_file_id) {
p_module->source_file = p_string->string;
break;
}
}
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseFunction(Parser* p_parser, Node* p_func_node, Function* p_func, size_t first_label_index)
{
p_func->id = p_func_node->result_id;
p_func->callee_count = 0;
p_func->accessed_ptr_count = 0;
for (size_t i = first_label_index; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (p_node->op == SpvOpFunctionEnd) {
break;
}
switch (p_node->op) {
case SpvOpFunctionCall: {
++(p_func->callee_count);
}
break;
case SpvOpLoad:
case SpvOpAccessChain:
case SpvOpInBoundsAccessChain:
case SpvOpPtrAccessChain:
case SpvOpArrayLength:
case SpvOpGenericPtrMemSemantics:
case SpvOpInBoundsPtrAccessChain:
case SpvOpStore:
{
++(p_func->accessed_ptr_count);
}
break;
case SpvOpCopyMemory:
case SpvOpCopyMemorySized:
{
p_func->accessed_ptr_count += 2;
}
break;
default: break;
}
}
if (p_func->callee_count > 0) {
p_func->callees = (uint32_t*)calloc(p_func->callee_count,
sizeof(*(p_func->callees)));
if (IsNull(p_func->callees)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
if (p_func->accessed_ptr_count > 0) {
p_func->accessed_ptrs = (uint32_t*)calloc(p_func->accessed_ptr_count,
sizeof(*(p_func->accessed_ptrs)));
if (IsNull(p_func->accessed_ptrs)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
p_func->callee_count = 0;
p_func->accessed_ptr_count = 0;
for (size_t i = first_label_index; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (p_node->op == SpvOpFunctionEnd) {
break;
}
switch (p_node->op) {
case SpvOpFunctionCall: {
CHECKED_READU32(p_parser, p_node->word_offset + 3,
p_func->callees[p_func->callee_count]);
(++p_func->callee_count);
}
break;
case SpvOpLoad:
case SpvOpAccessChain:
case SpvOpInBoundsAccessChain:
case SpvOpPtrAccessChain:
case SpvOpArrayLength:
case SpvOpGenericPtrMemSemantics:
case SpvOpInBoundsPtrAccessChain:
{
CHECKED_READU32(p_parser, p_node->word_offset + 3,
p_func->accessed_ptrs[p_func->accessed_ptr_count]);
(++p_func->accessed_ptr_count);
}
break;
case SpvOpStore:
{
CHECKED_READU32(p_parser, p_node->word_offset + 2,
p_func->accessed_ptrs[p_func->accessed_ptr_count]);
(++p_func->accessed_ptr_count);
}
break;
case SpvOpCopyMemory:
case SpvOpCopyMemorySized:
{
CHECKED_READU32(p_parser, p_node->word_offset + 2,
p_func->accessed_ptrs[p_func->accessed_ptr_count]);
(++p_func->accessed_ptr_count);
CHECKED_READU32(p_parser, p_node->word_offset + 3,
p_func->accessed_ptrs[p_func->accessed_ptr_count]);
(++p_func->accessed_ptr_count);
}
break;
default: break;
}
}
if (p_func->callee_count > 0) {
qsort(p_func->callees, p_func->callee_count,
sizeof(*(p_func->callees)), SortCompareUint32);
}
p_func->callee_count = (uint32_t)DedupSortedUint32(p_func->callees,
p_func->callee_count);
if (p_func->accessed_ptr_count > 0) {
qsort(p_func->accessed_ptrs, p_func->accessed_ptr_count,
sizeof(*(p_func->accessed_ptrs)), SortCompareUint32);
}
p_func->accessed_ptr_count = (uint32_t)DedupSortedUint32(p_func->accessed_ptrs,
p_func->accessed_ptr_count);
return SPV_REFLECT_RESULT_SUCCESS;
}
static int SortCompareFunctions(const void* a, const void* b)
{
const Function* af = (const Function*)a;
const Function* bf = (const Function*)b;
return (int)af->id - (int)bf->id;
}
static SpvReflectResult ParseFunctions(Parser* p_parser)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
assert(IsNotNull(p_parser->nodes));
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
if (p_parser->function_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
p_parser->functions = (Function*)calloc(p_parser->function_count,
sizeof(*(p_parser->functions)));
if (IsNull(p_parser->functions)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
size_t function_index = 0;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (p_node->op != SpvOpFunction) {
continue;
}
// Skip over function declarations that aren't definitions
bool func_definition = false;
// Intentionally reuse i to avoid iterating over these nodes more than
// once
for (; i < p_parser->node_count; ++i) {
if (p_parser->nodes[i].op == SpvOpLabel) {
func_definition = true;
break;
}
if (p_parser->nodes[i].op == SpvOpFunctionEnd) {
break;
}
}
if (!func_definition) {
continue;
}
Function* p_function = &(p_parser->functions[function_index]);
SpvReflectResult result = ParseFunction(p_parser, p_node, p_function, i);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
++function_index;
}
qsort(p_parser->functions, p_parser->function_count,
sizeof(*(p_parser->functions)), SortCompareFunctions);
// Once they're sorted, link the functions with pointers to improve graph
// traversal efficiency
for (size_t i = 0; i < p_parser->function_count; ++i) {
Function* p_func = &(p_parser->functions[i]);
if (p_func->callee_count == 0) {
continue;
}
p_func->callee_ptrs = (Function**)calloc(p_func->callee_count,
sizeof(*(p_func->callee_ptrs)));
for (size_t j = 0, k = 0; j < p_func->callee_count; ++j) {
while (p_parser->functions[k].id != p_func->callees[j]) {
++k;
if (k >= p_parser->function_count) {
// Invalid called function ID somewhere
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
p_func->callee_ptrs[j] = &(p_parser->functions[k]);
}
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseMemberCounts(Parser* p_parser)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
assert(IsNotNull(p_parser->nodes));
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if ((p_node->op != SpvOpMemberName) && (p_node->op != SpvOpMemberDecorate)) {
continue;
}
uint32_t target_id = 0;
uint32_t member_index = (uint32_t)INVALID_VALUE;
CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
CHECKED_READU32(p_parser, p_node->word_offset + 2, member_index);
Node* p_target_node = FindNode(p_parser, target_id);
// Not all nodes get parsed, so FindNode returning NULL is expected.
if (IsNull(p_target_node)) {
continue;
}
if (member_index == INVALID_VALUE) {
return SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED;
}
p_target_node->member_count = Max(p_target_node->member_count, member_index + 1);
}
for (uint32_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (p_node->member_count == 0) {
continue;
}
p_node->member_names = (const char **)calloc(p_node->member_count, sizeof(*(p_node->member_names)));
if (IsNull(p_node->member_names)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
p_node->member_decorations = (Decorations*)calloc(p_node->member_count, sizeof(*(p_node->member_decorations)));
if (IsNull(p_node->member_decorations)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseNames(Parser* p_parser)
{
assert(IsNotNull(p_parser));
assert(IsNotNull(p_parser->spirv_code));
assert(IsNotNull(p_parser->nodes));
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if ((p_node->op != SpvOpName) && (p_node->op != SpvOpMemberName)) {
continue;
}
uint32_t target_id = 0;
CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
Node* p_target_node = FindNode(p_parser, target_id);
// Not all nodes get parsed, so FindNode returning NULL is expected.
if (IsNull(p_target_node)) {
continue;
}
const char** pp_target_name = &(p_target_node->name);
if (p_node->op == SpvOpMemberName) {
uint32_t member_index = UINT32_MAX;
CHECKED_READU32(p_parser, p_node->word_offset + 2, member_index);
pp_target_name = &(p_target_node->member_names[member_index]);
}
*pp_target_name = p_node->name;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDecorations(Parser* p_parser)
{
for (uint32_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (((uint32_t)p_node->op != (uint32_t)SpvOpDecorate) &&
((uint32_t)p_node->op != (uint32_t)SpvOpMemberDecorate) &&
((uint32_t)p_node->op != (uint32_t)SpvReflectOpDecorateId) &&
((uint32_t)p_node->op != (uint32_t)SpvReflectOpDecorateStringGOOGLE) &&
((uint32_t)p_node->op != (uint32_t)SpvReflectOpMemberDecorateStringGOOGLE))
{
continue;
}
// Need to adjust the read offset if this is a member decoration
uint32_t member_offset = 0;
if (p_node->op == SpvOpMemberDecorate) {
member_offset = 1;
}
// Get decoration
uint32_t decoration = (uint32_t)INVALID_VALUE;
CHECKED_READU32(p_parser, p_node->word_offset + member_offset + 2, decoration);
// Filter out the decoration that do not affect reflection, otherwise
// there will be random crashes because the nodes aren't found.
bool skip = false;
switch (decoration) {
default: {
skip = true;
}
break;
case SpvDecorationBlock:
case SpvDecorationBufferBlock:
case SpvDecorationColMajor:
case SpvDecorationRowMajor:
case SpvDecorationArrayStride:
case SpvDecorationMatrixStride:
case SpvDecorationBuiltIn:
case SpvDecorationNoPerspective:
case SpvDecorationFlat:
case SpvDecorationNonWritable:
case SpvDecorationLocation:
case SpvDecorationBinding:
case SpvDecorationDescriptorSet:
case SpvDecorationOffset:
case SpvDecorationInputAttachmentIndex:
case SpvReflectDecorationHlslCounterBufferGOOGLE:
case SpvReflectDecorationHlslSemanticGOOGLE: {
skip = false;
}
break;
}
if (skip) {
continue;
}
// Find target target node
uint32_t target_id = 0;
CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
Node* p_target_node = FindNode(p_parser, target_id);
if (IsNull(p_target_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Get decorations
Decorations* p_target_decorations = &(p_target_node->decorations);
// Update pointer if this is a member member decoration
if (p_node->op == SpvOpMemberDecorate) {
uint32_t member_index = (uint32_t)INVALID_VALUE;
CHECKED_READU32(p_parser, p_node->word_offset + 2, member_index);
p_target_decorations = &(p_target_node->member_decorations[member_index]);
}
switch (decoration) {
default: break;
case SpvDecorationBlock: {
p_target_decorations->is_block = true;
}
break;
case SpvDecorationBufferBlock: {
p_target_decorations->is_buffer_block = true;
}
break;
case SpvDecorationColMajor: {
p_target_decorations->is_column_major = true;
}
break;
case SpvDecorationRowMajor: {
p_target_decorations->is_row_major = true;
}
break;
case SpvDecorationArrayStride: {
uint32_t word_offset = p_node->word_offset + member_offset + 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->array_stride);
}
break;
case SpvDecorationMatrixStride: {
uint32_t word_offset = p_node->word_offset + member_offset + 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->matrix_stride);
}
break;
case SpvDecorationBuiltIn: {
p_target_decorations->is_built_in = true;
uint32_t word_offset = p_node->word_offset + member_offset + 3;
CHECKED_READU32_CAST(p_parser, word_offset, SpvBuiltIn, p_target_decorations->built_in);
}
break;
case SpvDecorationNoPerspective: {
p_target_decorations->is_noperspective = true;
}
break;
case SpvDecorationFlat: {
p_target_decorations->is_flat = true;
}
break;
case SpvDecorationNonWritable: {
p_target_decorations->is_non_writable = true;
}
break;
case SpvDecorationLocation: {
uint32_t word_offset = p_node->word_offset + member_offset + 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->location.value);
p_target_decorations->location.word_offset = word_offset;
}
break;
case SpvDecorationBinding: {
uint32_t word_offset = p_node->word_offset + member_offset+ 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->binding.value);
p_target_decorations->binding.word_offset = word_offset;
}
break;
case SpvDecorationDescriptorSet: {
uint32_t word_offset = p_node->word_offset + member_offset+ 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->set.value);
p_target_decorations->set.word_offset = word_offset;
}
break;
case SpvDecorationOffset: {
uint32_t word_offset = p_node->word_offset + member_offset+ 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->offset.value);
p_target_decorations->offset.word_offset = word_offset;
}
break;
case SpvDecorationInputAttachmentIndex: {
uint32_t word_offset = p_node->word_offset + member_offset+ 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->input_attachment_index.value);
p_target_decorations->input_attachment_index.word_offset = word_offset;
}
break;
case SpvReflectDecorationHlslCounterBufferGOOGLE: {
uint32_t word_offset = p_node->word_offset + member_offset+ 3;
CHECKED_READU32(p_parser, word_offset, p_target_decorations->uav_counter_buffer.value);
p_target_decorations->uav_counter_buffer.word_offset = word_offset;
}
break;
case SpvReflectDecorationHlslSemanticGOOGLE: {
uint32_t word_offset = p_node->word_offset + member_offset + 3;
p_target_decorations->semantic.value = (const char*)(p_parser->spirv_code + word_offset);
p_target_decorations->semantic.word_offset = word_offset;
}
break;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult EnumerateAllUniforms(
SpvReflectShaderModule* p_module,
size_t* p_uniform_count,
uint32_t** pp_uniforms
)
{
*p_uniform_count = p_module->descriptor_binding_count;
if (*p_uniform_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
*pp_uniforms = (uint32_t*)calloc(*p_uniform_count, sizeof(**pp_uniforms));
if (IsNull(*pp_uniforms)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
for (size_t i = 0; i < *p_uniform_count; ++i) {
(*pp_uniforms)[i] = p_module->descriptor_bindings[i].spirv_id;
}
qsort(*pp_uniforms, *p_uniform_count, sizeof(**pp_uniforms),
SortCompareUint32);
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseType(
Parser* p_parser,
Node* p_node,
Decorations* p_struct_member_decorations,
SpvReflectShaderModule* p_module,
SpvReflectTypeDescription* p_type
)
{
SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
if (p_node->member_count > 0) {
p_type->member_count = p_node->member_count;
p_type->members = (SpvReflectTypeDescription*)calloc(p_type->member_count, sizeof(*(p_type->members)));
if (IsNotNull(p_type->members)) {
// Mark all members types with an invalid state
for (size_t i = 0; i < p_type->members->member_count; ++i) {
SpvReflectTypeDescription* p_member_type = &(p_type->members[i]);
p_member_type->id = (uint32_t)INVALID_VALUE;
p_member_type->op = (SpvOp)INVALID_VALUE;
p_member_type->storage_class = (SpvStorageClass)INVALID_VALUE;
}
}
else {
result = SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
// Since the parse descends on type information, these will get overwritten
// if not guarded against assignment. Only assign if the id is invalid.
if (p_type->id == INVALID_VALUE) {
p_type->id = p_node->result_id;
p_type->op = p_node->op;
p_type->decoration_flags = 0;
}
// Top level types need to pick up decorations from all types below it.
// Issue and fix here: https://github.com/chaoticbob/SPIRV-Reflect/issues/64
p_type->decoration_flags = ApplyDecorations(&p_node->decorations);
switch (p_node->op) {
default: break;
case SpvOpTypeVoid:
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_VOID;
break;
case SpvOpTypeBool:
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_BOOL;
break;
case SpvOpTypeInt: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_INT;
IF_READU32(result, p_parser, p_node->word_offset + 2, p_type->traits.numeric.scalar.width);
IF_READU32(result, p_parser, p_node->word_offset + 3, p_type->traits.numeric.scalar.signedness);
}
break;
case SpvOpTypeFloat: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_FLOAT;
IF_READU32(result, p_parser, p_node->word_offset + 2, p_type->traits.numeric.scalar.width);
}
break;
case SpvOpTypeVector: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_VECTOR;
uint32_t component_type_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + 2, component_type_id);
IF_READU32(result, p_parser, p_node->word_offset + 3, p_type->traits.numeric.vector.component_count);
// Parse component type
Node* p_next_node = FindNode(p_parser, component_type_id);
if (IsNotNull(p_next_node)) {
result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
}
else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
break;
case SpvOpTypeMatrix: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_MATRIX;
uint32_t column_type_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + 2, column_type_id);
IF_READU32(result, p_parser, p_node->word_offset + 3, p_type->traits.numeric.matrix.column_count);
Node* p_next_node = FindNode(p_parser, column_type_id);
if (IsNotNull(p_next_node)) {
result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
}
else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
p_type->traits.numeric.matrix.row_count = p_type->traits.numeric.vector.component_count;
p_type->traits.numeric.matrix.stride = p_node->decorations.matrix_stride;
// NOTE: Matrix stride is decorated using OpMemberDecoreate - not OpDecoreate.
if (IsNotNull(p_struct_member_decorations)) {
p_type->traits.numeric.matrix.stride = p_struct_member_decorations->matrix_stride;
}
}
break;
case SpvOpTypeImage: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE;
IF_READU32_CAST(result, p_parser, p_node->word_offset + 3, SpvDim, p_type->traits.image.dim);
IF_READU32(result, p_parser, p_node->word_offset + 4, p_type->traits.image.depth);
IF_READU32(result, p_parser, p_node->word_offset + 5, p_type->traits.image.arrayed);
IF_READU32(result, p_parser, p_node->word_offset + 6, p_type->traits.image.ms);
IF_READU32(result, p_parser, p_node->word_offset + 7, p_type->traits.image.sampled);
IF_READU32_CAST(result, p_parser, p_node->word_offset + 8, SpvImageFormat, p_type->traits.image.image_format);
}
break;
case SpvOpTypeSampler: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLER;
}
break;
case SpvOpTypeSampledImage: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLED_IMAGE;
uint32_t image_type_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + 2, image_type_id);
Node* p_next_node = FindNode(p_parser, image_type_id);
if (IsNotNull(p_next_node)) {
result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
}
else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
break;
case SpvOpTypeArray: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_ARRAY;
if (result == SPV_REFLECT_RESULT_SUCCESS) {
uint32_t element_type_id = (uint32_t)INVALID_VALUE;
uint32_t length_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + 2, element_type_id);
IF_READU32(result, p_parser, p_node->word_offset + 3, length_id);
// NOTE: Array stride is decorated using OpDecorate instead of
// OpMemberDecorate, even if the array is apart of a struct.
p_type->traits.array.stride = p_node->decorations.array_stride;
// Get length for current dimension
Node* p_length_node = FindNode(p_parser, length_id);
if (IsNotNull(p_length_node)) {
if (p_length_node->op == SpvOpSpecConstant ||
p_length_node->op == SpvOpSpecConstantOp) {
p_type->traits.array.dims[p_type->traits.array.dims_count] = 0xFFFFFFFF;
p_type->traits.array.dims_count += 1;
} else {
uint32_t length = 0;
IF_READU32(result, p_parser, p_length_node->word_offset + 3, length);
if (result == SPV_REFLECT_RESULT_SUCCESS) {
// Write the array dim and increment the count and offset
p_type->traits.array.dims[p_type->traits.array.dims_count] = length;
p_type->traits.array.dims_count += 1;
} else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
// Parse next dimension or element type
Node* p_next_node = FindNode(p_parser, element_type_id);
if (IsNotNull(p_next_node)) {
result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
}
}
else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
}
break;
case SpvOpTypeRuntimeArray: {
uint32_t element_type_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + 2, element_type_id);
// Parse next dimension or element type
Node* p_next_node = FindNode(p_parser, element_type_id);
if (IsNotNull(p_next_node)) {
result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
}
else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
break;
case SpvOpTypeStruct: {
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_STRUCT;
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_BLOCK;
uint32_t word_index = 2;
uint32_t member_index = 0;
for (; word_index < p_node->word_count; ++word_index, ++member_index) {
uint32_t member_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + word_index, member_id);
// Find member node
Node* p_member_node = FindNode(p_parser, member_id);
if (IsNull(p_member_node)) {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
break;
}
// Member decorations
Decorations* p_member_decorations = &p_node->member_decorations[member_index];
assert(member_index < p_type->member_count);
// Parse member type
SpvReflectTypeDescription* p_member_type = &(p_type->members[member_index]);
p_member_type->id = member_id;
p_member_type->op = p_member_node->op;
result = ParseType(p_parser, p_member_node, p_member_decorations, p_module, p_member_type);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
break;
}
// This looks wrong
//p_member_type->type_name = p_member_node->name;
p_member_type->struct_member_name = p_node->member_names[member_index];
}
}
break;
case SpvOpTypeOpaque: break;
case SpvOpTypePointer: {
IF_READU32_CAST(result, p_parser, p_node->word_offset + 2, SpvStorageClass, p_type->storage_class);
uint32_t type_id = (uint32_t)INVALID_VALUE;
IF_READU32(result, p_parser, p_node->word_offset + 3, type_id);
// Parse type
Node* p_next_node = FindNode(p_parser, type_id);
if (IsNotNull(p_next_node)) {
result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
}
else {
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
break;
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
// Names get assigned on the way down. Guard against names
// get overwritten on the way up.
if (IsNull(p_type->type_name)) {
p_type->type_name = p_node->name;
}
}
}
return result;
}
static SpvReflectResult ParseTypes(Parser* p_parser, SpvReflectShaderModule* p_module)
{
if (p_parser->type_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
p_module->_internal->type_description_count = p_parser->type_count;
p_module->_internal->type_descriptions = (SpvReflectTypeDescription*)calloc(p_module->_internal->type_description_count,
sizeof(*(p_module->_internal->type_descriptions)));
if (IsNull(p_module->_internal->type_descriptions)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
// Mark all types with an invalid state
for (size_t i = 0; i < p_module->_internal->type_description_count; ++i) {
SpvReflectTypeDescription* p_type = &(p_module->_internal->type_descriptions[i]);
p_type->id = (uint32_t)INVALID_VALUE;
p_type->op = (SpvOp)INVALID_VALUE;
p_type->storage_class = (SpvStorageClass)INVALID_VALUE;
}
size_t type_index = 0;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (! p_node->is_type) {
continue;
}
SpvReflectTypeDescription* p_type = &(p_module->_internal->type_descriptions[type_index]);
SpvReflectResult result = ParseType(p_parser, p_node, NULL, p_module, p_type);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
++type_index;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static int SortCompareDescriptorBinding(const void* a, const void* b)
{
const SpvReflectDescriptorBinding* p_elem_a = (const SpvReflectDescriptorBinding*)a;
const SpvReflectDescriptorBinding* p_elem_b = (const SpvReflectDescriptorBinding*)b;
int value = (int)(p_elem_a->binding) - (int)(p_elem_b->binding);
if (value == 0) {
// use spirv-id as a tiebreaker to ensure a stable ordering, as they're guaranteed
// unique.
assert(p_elem_a->spirv_id != p_elem_b->spirv_id);
value = (int)(p_elem_a->spirv_id) - (int)(p_elem_b->spirv_id);
}
return value;
}
static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShaderModule* p_module)
{
p_module->descriptor_binding_count = 0;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if ((p_node->op != SpvOpVariable) ||
((p_node->storage_class != SpvStorageClassUniform) && (p_node->storage_class != SpvStorageClassUniformConstant)))
{
continue;
}
if ((p_node->decorations.set.value == INVALID_VALUE) || (p_node->decorations.binding.value == INVALID_VALUE)) {
continue;
}
p_module->descriptor_binding_count += 1;
}
if (p_module->descriptor_binding_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
p_module->descriptor_bindings = (SpvReflectDescriptorBinding*)calloc(p_module->descriptor_binding_count, sizeof(*(p_module->descriptor_bindings)));
if (IsNull(p_module->descriptor_bindings)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
// Mark all types with an invalid state
for (uint32_t descriptor_index = 0; descriptor_index < p_module->descriptor_binding_count; ++descriptor_index) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[descriptor_index]);
p_descriptor->binding = (uint32_t)INVALID_VALUE;
p_descriptor->input_attachment_index = (uint32_t)INVALID_VALUE;
p_descriptor->set = (uint32_t)INVALID_VALUE;
p_descriptor->descriptor_type = (SpvReflectDescriptorType)INVALID_VALUE;
p_descriptor->uav_counter_id = (uint32_t)INVALID_VALUE;
}
size_t descriptor_index = 0;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if ((p_node->op != SpvOpVariable) ||
((p_node->storage_class != SpvStorageClassUniform) && (p_node->storage_class != SpvStorageClassUniformConstant)))\
{
continue;
}
if ((p_node->decorations.set.value == INVALID_VALUE) || (p_node->decorations.binding.value == INVALID_VALUE)) {
continue;
}
SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
if (IsNull(p_type)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// If the type is a pointer, resolve it
if (p_type->op == SpvOpTypePointer) {
// Find the type's node
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Should be the resolved type
p_type = FindType(p_module, p_type_node->type_id);
if (IsNull(p_type)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
SpvReflectDescriptorBinding* p_descriptor = &p_module->descriptor_bindings[descriptor_index];
p_descriptor->spirv_id = p_node->result_id;
p_descriptor->name = p_node->name;
p_descriptor->binding = p_node->decorations.binding.value;
p_descriptor->input_attachment_index = p_node->decorations.input_attachment_index.value;
p_descriptor->set = p_node->decorations.set.value;
p_descriptor->count = 1;
p_descriptor->uav_counter_id = p_node->decorations.uav_counter_buffer.value;
p_descriptor->type_description = p_type;
// Copy image traits
if ((p_type->type_flags & SPV_REFLECT_TYPE_FLAG_EXTERNAL_MASK) == SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE) {
memcpy(&p_descriptor->image, &p_type->traits.image, sizeof(p_descriptor->image));
}
// This is a workaround for: https://github.com/KhronosGroup/glslang/issues/1096
{
const uint32_t resource_mask = SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLED_IMAGE | SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE;
if ((p_type->type_flags & resource_mask) == resource_mask) {
memcpy(&p_descriptor->image, &p_type->traits.image, sizeof(p_descriptor->image));
}
}
// Copy array traits
if (p_type->traits.array.dims_count > 0) {
p_descriptor->array.dims_count = p_type->traits.array.dims_count;
for (uint32_t dim_index = 0; dim_index < p_type->traits.array.dims_count; ++dim_index) {
uint32_t dim_value = p_type->traits.array.dims[dim_index];
p_descriptor->array.dims[dim_index] = dim_value;
p_descriptor->count *= dim_value;
}
}
// Count
p_descriptor->word_offset.binding = p_node->decorations.binding.word_offset;
p_descriptor->word_offset.set = p_node->decorations.set.word_offset;
++descriptor_index;
}
if (p_module->descriptor_binding_count > 0) {
qsort(p_module->descriptor_bindings,
p_module->descriptor_binding_count,
sizeof(*(p_module->descriptor_bindings)),
SortCompareDescriptorBinding);
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDescriptorType(SpvReflectShaderModule* p_module)
{
if (p_module->descriptor_binding_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
for (uint32_t descriptor_index = 0; descriptor_index < p_module->descriptor_binding_count; ++descriptor_index) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[descriptor_index]);
SpvReflectTypeDescription* p_type = p_descriptor->type_description;
switch (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_EXTERNAL_MASK) {
default: assert(false && "unknown type flag"); break;
case SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE: {
if (p_descriptor->image.dim == SpvDimBuffer) {
switch (p_descriptor->image.sampled) {
default: assert(false && "unknown texel buffer sampled value"); break;
case IMAGE_SAMPLED: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; break;
case IMAGE_STORAGE: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; break;
}
}
else if(p_descriptor->image.dim == SpvDimSubpassData) {
p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
}
else {
switch (p_descriptor->image.sampled) {
default: assert(false && "unknown image sampled value"); break;
case IMAGE_SAMPLED: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE; break;
case IMAGE_STORAGE: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE; break;
}
}
}
break;
case SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLER: {
p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER;
}
break;
case (SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLED_IMAGE | SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE): {
// This is a workaround for: https://github.com/KhronosGroup/glslang/issues/1096
if (p_descriptor->image.dim == SpvDimBuffer) {
switch (p_descriptor->image.sampled) {
default: assert(false && "unknown texel buffer sampled value"); break;
case IMAGE_SAMPLED: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; break;
case IMAGE_STORAGE: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; break;
}
}
else {
p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
}
}
break;
case SPV_REFLECT_TYPE_FLAG_EXTERNAL_BLOCK: {
if (p_type->decoration_flags & SPV_REFLECT_DECORATION_BLOCK) {
p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
}
else if (p_type->decoration_flags & SPV_REFLECT_DECORATION_BUFFER_BLOCK) {
p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER;
}
else {
assert(false && "unknown struct");
}
}
break;
}
switch (p_descriptor->descriptor_type) {
case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SAMPLER; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : p_descriptor->resource_type = (SpvReflectResourceType)(SPV_REFLECT_RESOURCE_FLAG_SAMPLER | SPV_REFLECT_RESOURCE_FLAG_SRV); break;
case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_CBV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_CBV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
case SPV_REFLECT_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
break;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module)
{
char name[MAX_NODE_NAME_LENGTH];
const char* k_count_tag = "@count";
for (uint32_t descriptor_index = 0; descriptor_index < p_module->descriptor_binding_count; ++descriptor_index) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[descriptor_index]);
if (p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
continue;
}
SpvReflectDescriptorBinding* p_counter_descriptor = NULL;
// Use UAV counter buffer id if present...
if (p_descriptor->uav_counter_id != UINT32_MAX) {
for (uint32_t counter_descriptor_index = 0; counter_descriptor_index < p_module->descriptor_binding_count; ++counter_descriptor_index) {
SpvReflectDescriptorBinding* p_test_counter_descriptor = &(p_module->descriptor_bindings[counter_descriptor_index]);
if (p_test_counter_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
continue;
}
if (p_descriptor->uav_counter_id == p_test_counter_descriptor->spirv_id) {
p_counter_descriptor = p_test_counter_descriptor;
break;
}
}
}
// ...otherwise use old @count convention.
else {
const size_t descriptor_name_length = p_descriptor->name? strlen(p_descriptor->name): 0;
memset(name, 0, MAX_NODE_NAME_LENGTH);
memcpy(name, p_descriptor->name, descriptor_name_length);
#if defined(WIN32)
strcat_s(name, MAX_NODE_NAME_LENGTH, k_count_tag);
#else
strcat(name, k_count_tag);
#endif
for (uint32_t counter_descriptor_index = 0; counter_descriptor_index < p_module->descriptor_binding_count; ++counter_descriptor_index) {
SpvReflectDescriptorBinding* p_test_counter_descriptor = &(p_module->descriptor_bindings[counter_descriptor_index]);
if (p_test_counter_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
continue;
}
if (p_test_counter_descriptor->name && strcmp(name, p_test_counter_descriptor->name) == 0) {
p_counter_descriptor = p_test_counter_descriptor;
break;
}
}
}
if (p_counter_descriptor != NULL) {
p_descriptor->uav_counter_binding = p_counter_descriptor;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDescriptorBlockVariable(
Parser* p_parser,
SpvReflectShaderModule* p_module,
SpvReflectTypeDescription* p_type,
SpvReflectBlockVariable* p_var
)
{
bool has_non_writable = false;
if (IsNotNull(p_type->members) && (p_type->member_count > 0)) {
p_var->member_count = p_type->member_count;
p_var->members = (SpvReflectBlockVariable*)calloc(p_var->member_count, sizeof(*p_var->members));
if (IsNull(p_var->members)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Resolve to element type if current type is array or run time array
if (p_type_node->op == SpvOpTypeArray) {
while (p_type_node->op == SpvOpTypeArray) {
p_type_node = FindNode(p_parser, p_type_node->array_traits.element_type_id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
}
else if(p_type_node->op == SpvOpTypeRuntimeArray) {
// Element type description
p_type = FindType(p_module, p_type_node->array_traits.element_type_id);
if (IsNull(p_type)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Element type node
p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
// Parse members
for (uint32_t member_index = 0; member_index < p_type->member_count; ++member_index) {
SpvReflectTypeDescription* p_member_type = &p_type->members[member_index];
SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
bool is_struct = (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) == SPV_REFLECT_TYPE_FLAG_STRUCT;
if (is_struct) {
SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_member_type, p_member_var);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
p_member_var->name = p_type_node->member_names[member_index];
p_member_var->offset = p_type_node->member_decorations[member_index].offset.value;
p_member_var->decoration_flags = ApplyDecorations(&p_type_node->member_decorations[member_index]);
p_member_var->flags |= SPV_REFLECT_VARIABLE_FLAGS_UNUSED;
if (!has_non_writable && (p_member_var->decoration_flags & SPV_REFLECT_DECORATION_NON_WRITABLE)) {
has_non_writable = true;
}
ApplyNumericTraits(p_member_type, &p_member_var->numeric);
if (p_member_type->op == SpvOpTypeArray) {
ApplyArrayTraits(p_member_type, &p_member_var->array);
}
p_member_var->type_description = p_member_type;
}
}
p_var->name = p_type->type_name;
p_var->type_description = p_type;
if (has_non_writable) {
p_var->decoration_flags |= SPV_REFLECT_DECORATION_NON_WRITABLE;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDescriptorBlockVariableSizes(
Parser* p_parser,
SpvReflectShaderModule* p_module,
bool is_parent_root,
bool is_parent_aos,
bool is_parent_rta,
SpvReflectBlockVariable* p_var
)
{
if (p_var->member_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
// Absolute offsets
for (uint32_t member_index = 0; member_index < p_var->member_count; ++member_index) {
SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
if (is_parent_root) {
p_member_var->absolute_offset = p_member_var->offset;
}
else {
p_member_var->absolute_offset = is_parent_aos ? 0 : p_member_var->offset + p_var->absolute_offset;
}
}
// Size
for (uint32_t member_index = 0; member_index < p_var->member_count; ++member_index) {
SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
SpvReflectTypeDescription* p_member_type = p_member_var->type_description;
switch (p_member_type->op) {
case SpvOpTypeBool: {
p_member_var->size = SPIRV_WORD_SIZE;
}
break;
case SpvOpTypeInt:
case SpvOpTypeFloat: {
p_member_var->size = p_member_type->traits.numeric.scalar.width / SPIRV_BYTE_WIDTH;
}
break;
case SpvOpTypeVector: {
uint32_t size = p_member_type->traits.numeric.vector.component_count *
(p_member_type->traits.numeric.scalar.width / SPIRV_BYTE_WIDTH);
p_member_var->size = size;
}
break;
case SpvOpTypeMatrix: {
if (p_member_var->decoration_flags & SPV_REFLECT_DECORATION_COLUMN_MAJOR) {
p_member_var->size = p_member_var->numeric.matrix.column_count * p_member_var->numeric.matrix.stride;
}
else if (p_member_var->decoration_flags & SPV_REFLECT_DECORATION_ROW_MAJOR) {
p_member_var->size = p_member_var->numeric.matrix.row_count * p_member_var->numeric.matrix.stride;
}
}
break;
case SpvOpTypeArray: {
// If array of structs, parse members first...
bool is_struct = (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) == SPV_REFLECT_TYPE_FLAG_STRUCT;
if (is_struct) {
SpvReflectResult result = ParseDescriptorBlockVariableSizes(p_parser, p_module, false, true, is_parent_rta, p_member_var);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
// ...then array
uint32_t element_count = (p_member_var->array.dims_count > 0 ? 1 : 0);
for (uint32_t i = 0; i < p_member_var->array.dims_count; ++i) {
element_count *= p_member_var->array.dims[i];
}
p_member_var->size = element_count * p_member_var->array.stride;
}
break;
case SpvOpTypeRuntimeArray: {
bool is_struct = (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) == SPV_REFLECT_TYPE_FLAG_STRUCT;
if (is_struct) {
SpvReflectResult result = ParseDescriptorBlockVariableSizes(p_parser, p_module, false, true, true, p_member_var);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
}
break;
case SpvOpTypeStruct: {
SpvReflectResult result = ParseDescriptorBlockVariableSizes(p_parser, p_module, false, is_parent_aos, is_parent_rta, p_member_var);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
break;
default:
break;
}
}
// Parse padded size using offset difference for all member except for the last entry...
for (uint32_t member_index = 0; member_index < (p_var->member_count - 1); ++member_index) {
SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
SpvReflectBlockVariable* p_next_member_var = &p_var->members[member_index + 1];
p_member_var->padded_size = p_next_member_var->offset - p_member_var->offset;
if (p_member_var->size > p_member_var->padded_size) {
p_member_var->size = p_member_var->padded_size;
}
if (is_parent_rta) {
p_member_var->padded_size = p_member_var->size;
}
}
// ...last entry just gets rounded up to near multiple of SPIRV_DATA_ALIGNMENT, which is 16 and
// subtract the offset.
if (p_var->member_count > 0) {
SpvReflectBlockVariable* p_member_var = &p_var->members[p_var->member_count - 1];
p_member_var->padded_size = RoundUp(p_member_var->offset + p_member_var->size, SPIRV_DATA_ALIGNMENT) - p_member_var->offset;
if (p_member_var->size > p_member_var->padded_size) {
p_member_var->size = p_member_var->padded_size;
}
if (is_parent_rta) {
p_member_var->padded_size = p_member_var->size;
}
}
// @TODO validate this with assertion
p_var->size = p_var->members[p_var->member_count - 1].offset +
p_var->members[p_var->member_count - 1].padded_size;
p_var->padded_size = p_var->size;
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDescriptorBlockVariableUsage(
Parser* p_parser,
SpvReflectShaderModule* p_module,
AccessChain* p_access_chain,
uint32_t index_index,
SpvOp override_op_type,
SpvReflectBlockVariable* p_var
)
{
(void)p_parser;
(void)p_access_chain;
(void)p_var;
// Clear the current variable's USED flag
p_var->flags &= ~SPV_REFLECT_VARIABLE_FLAGS_UNUSED;
// Parsing arrays requires overriding the op type for
// for the lowest dim's element type.
SpvOp op_type = p_var->type_description->op;
if (override_op_type != (SpvOp)INVALID_VALUE) {
op_type = override_op_type;
}
switch (op_type) {
default: break;
case SpvOpTypeArray: {
// Parse through array's type hierarchy to find the actual/non-array element type
SpvReflectTypeDescription* p_type = p_var->type_description;
while ((p_type->op == SpvOpTypeArray) && (index_index < p_access_chain->index_count)) {
// Find the array element type id
Node* p_node = FindNode(p_parser, p_type->id);
if (p_node == NULL) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
uint32_t element_type_id = p_node->array_traits.element_type_id;
// Get the array element type
p_type = FindType(p_module, element_type_id);
if (p_type == NULL) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Next access index
index_index += 1;
}
// Parse current var again with a type override and advanced index index
SpvReflectResult result = ParseDescriptorBlockVariableUsage(
p_parser,
p_module,
p_access_chain,
index_index,
p_type->op,
p_var);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
break;
case SpvOpTypeStruct: {
assert(p_var->member_count > 0);
if (p_var->member_count == 0) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_BLOCK_DATA;
}
uint32_t index = p_access_chain->indexes[index_index];
if (index >= p_var->member_count) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_BLOCK_MEMBER_REFERENCE;
}
SpvReflectBlockVariable* p_member_var = &p_var->members[index];
if (index_index < p_access_chain->index_count) {
SpvReflectResult result = ParseDescriptorBlockVariableUsage(
p_parser,
p_module,
p_access_chain,
index_index + 1,
(SpvOp)INVALID_VALUE,
p_member_var);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
}
break;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDescriptorBlocks(Parser* p_parser, SpvReflectShaderModule* p_module)
{
if (p_module->descriptor_binding_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
for (uint32_t descriptor_index = 0; descriptor_index < p_module->descriptor_binding_count; ++descriptor_index) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[descriptor_index]);
SpvReflectTypeDescription* p_type = p_descriptor->type_description;
if ((p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER) &&
(p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) )
{
continue;
}
// Mark UNUSED
p_descriptor->block.flags |= SPV_REFLECT_VARIABLE_FLAGS_UNUSED;
// Parse descriptor block
SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_type, &p_descriptor->block);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
for (uint32_t access_chain_index = 0; access_chain_index < p_parser->access_chain_count; ++access_chain_index) {
AccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
// Skip any access chains that aren't touching this descriptor block
if (p_descriptor->spirv_id != p_access_chain->base_id) {
continue;
}
result = ParseDescriptorBlockVariableUsage(
p_parser,
p_module,
p_access_chain,
0,
(SpvOp)INVALID_VALUE,
&p_descriptor->block);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
p_descriptor->block.name = p_descriptor->name;
bool is_parent_rta = (p_descriptor->descriptor_type == SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER);
result = ParseDescriptorBlockVariableSizes(p_parser, p_module, true, false, is_parent_rta, &p_descriptor->block);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
if (is_parent_rta) {
p_descriptor->block.size = 0;
p_descriptor->block.padded_size = 0;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseFormat(
const SpvReflectTypeDescription* p_type,
SpvReflectFormat* p_format
)
{
SpvReflectResult result = SPV_REFLECT_RESULT_ERROR_INTERNAL_ERROR;
bool signedness = p_type->traits.numeric.scalar.signedness;
if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_VECTOR) {
uint32_t component_count = p_type->traits.numeric.vector.component_count;
if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_FLOAT) {
switch (component_count) {
case 2: *p_format = SPV_REFLECT_FORMAT_R32G32_SFLOAT; break;
case 3: *p_format = SPV_REFLECT_FORMAT_R32G32B32_SFLOAT; break;
case 4: *p_format = SPV_REFLECT_FORMAT_R32G32B32A32_SFLOAT; break;
}
result = SPV_REFLECT_RESULT_SUCCESS;
}
else if (p_type->type_flags & (SPV_REFLECT_TYPE_FLAG_INT | SPV_REFLECT_TYPE_FLAG_BOOL)) {
switch (component_count) {
case 2: *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32_SINT : SPV_REFLECT_FORMAT_R32G32_UINT; break;
case 3: *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32B32_SINT : SPV_REFLECT_FORMAT_R32G32B32_UINT; break;
case 4: *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32B32A32_SINT : SPV_REFLECT_FORMAT_R32G32B32A32_UINT; break;
}
result = SPV_REFLECT_RESULT_SUCCESS;
}
}
else if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_FLOAT) {
*p_format = SPV_REFLECT_FORMAT_R32_SFLOAT;
result = SPV_REFLECT_RESULT_SUCCESS;
}
else if (p_type->type_flags & (SPV_REFLECT_TYPE_FLAG_INT | SPV_REFLECT_TYPE_FLAG_BOOL)) {
if (signedness) {
*p_format = SPV_REFLECT_FORMAT_R32_SINT;
result = SPV_REFLECT_RESULT_SUCCESS;
}
else {
*p_format = SPV_REFLECT_FORMAT_R32_UINT;
result = SPV_REFLECT_RESULT_SUCCESS;
}
}
else if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) {
*p_format = SPV_REFLECT_FORMAT_UNDEFINED;
result = SPV_REFLECT_RESULT_SUCCESS;
}
return result;
}
static SpvReflectResult ParseInterfaceVariable(
Parser* p_parser,
const Decorations* p_type_node_decorations,
SpvReflectShaderModule* p_module,
SpvReflectTypeDescription* p_type,
SpvReflectInterfaceVariable* p_var,
bool* p_has_built_in
)
{
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
if (p_type->member_count > 0) {
p_var->member_count = p_type->member_count;
p_var->members = (SpvReflectInterfaceVariable*)calloc(p_var->member_count, sizeof(*p_var->members));
if (IsNull(p_var->members)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
for (uint32_t member_index = 0; member_index < p_type_node->member_count; ++member_index) {
Decorations* p_member_decorations = &p_type_node->member_decorations[member_index];
SpvReflectTypeDescription* p_member_type = &p_type->members[member_index];
SpvReflectInterfaceVariable* p_member_var = &p_var->members[member_index];
SpvReflectResult result = ParseInterfaceVariable(p_parser, p_member_decorations, p_module, p_member_type, p_member_var, p_has_built_in);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
}
p_var->name = p_type_node->name;
p_var->decoration_flags = ApplyDecorations(p_type_node_decorations);
p_var->built_in = p_type_node_decorations->built_in;
ApplyNumericTraits(p_type, &p_var->numeric);
if (p_type->op == SpvOpTypeArray) {
ApplyArrayTraits(p_type, &p_var->array);
}
p_var->type_description = p_type;
*p_has_built_in |= p_type_node_decorations->is_built_in;
SpvReflectResult result = ParseFormat(p_var->type_description, &p_var->format);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseInterfaceVariables(
Parser* p_parser,
SpvReflectShaderModule* p_module,
SpvReflectEntryPoint* p_entry,
size_t io_var_count,
uint32_t* io_vars
)
{
if (io_var_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
p_entry->input_variable_count = 0;
p_entry->output_variable_count = 0;
for (size_t i = 0; i < io_var_count; ++i) {
uint32_t var_result_id = *(io_vars + i);
Node* p_node = FindNode(p_parser, var_result_id);
if (IsNull(p_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
if (p_node->storage_class == SpvStorageClassInput) {
p_entry->input_variable_count += 1;
}
else if (p_node->storage_class == SpvStorageClassOutput) {
p_entry->output_variable_count += 1;
}
}
if (p_entry->input_variable_count > 0) {
p_entry->input_variables = (SpvReflectInterfaceVariable*)calloc(p_entry->input_variable_count, sizeof(*(p_entry->input_variables)));
if (IsNull(p_entry->input_variables)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
if (p_entry->output_variable_count > 0) {
p_entry->output_variables = (SpvReflectInterfaceVariable*)calloc(p_entry->output_variable_count, sizeof(*(p_entry->output_variables)));
if (IsNull(p_entry->output_variables)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
size_t input_index = 0;
size_t output_index = 0;
for (size_t i = 0; i < io_var_count; ++i) {
uint32_t var_result_id = *(io_vars + i);
Node* p_node = FindNode(p_parser, var_result_id);
if (IsNull(p_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
if (IsNull(p_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// If the type is a pointer, resolve it
if (p_type->op == SpvOpTypePointer) {
// Find the type's node
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Should be the resolved type
p_type = FindType(p_module, p_type_node->type_id);
if (IsNull(p_type)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
SpvReflectInterfaceVariable* p_var = NULL;
if (p_node->storage_class == SpvStorageClassInput) {
p_var = &(p_entry->input_variables[input_index]);
p_var->storage_class = SpvStorageClassInput;
++input_index;
}
else if (p_node->storage_class == SpvStorageClassOutput) {
p_var = &(p_entry->output_variables[output_index]);
p_var->storage_class = SpvStorageClassOutput;
++output_index;
} else {
// interface variables can only have input or output storage classes;
// anything else is either a new addition or an error.
assert(false && "Unsupported storage class for interface variable");
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_STORAGE_CLASS;
}
bool has_built_in = p_node->decorations.is_built_in;
SpvReflectResult result = ParseInterfaceVariable(
p_parser,
&p_type_node->decorations,
p_module,
p_type,
p_var,
&has_built_in);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
// SPIR-V result id
p_var->spirv_id = p_node->result_id;
// Name
p_var->name = p_node->name;
// Semantic
p_var->semantic = p_node->decorations.semantic.value;
// Decorate with built-in if any member is built-in
if (has_built_in) {
p_var->decoration_flags |= SPV_REFLECT_DECORATION_BUILT_IN;
}
// Location is decorated on OpVariable node, not the type node.
p_var->location = p_node->decorations.location.value;
p_var->word_offset.location = p_node->decorations.location.word_offset;
// Built in
if (p_node->decorations.is_built_in) {
p_var->built_in = p_node->decorations.built_in;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult EnumerateAllPushConstants(
SpvReflectShaderModule* p_module,
size_t* p_push_constant_count,
uint32_t** p_push_constants
)
{
*p_push_constant_count = p_module->push_constant_block_count;
if (*p_push_constant_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
*p_push_constants = (uint32_t*)calloc(*p_push_constant_count, sizeof(**p_push_constants));
if (IsNull(*p_push_constants)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
for (size_t i = 0; i < *p_push_constant_count; ++i) {
(*p_push_constants)[i] = p_module->push_constant_blocks[i].spirv_id;
}
qsort(*p_push_constants, *p_push_constant_count, sizeof(**p_push_constants),
SortCompareUint32);
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult TraverseCallGraph(
Parser* p_parser,
Function* p_func,
size_t* p_func_count,
uint32_t* p_func_ids,
uint32_t depth
)
{
if (depth > p_parser->function_count) {
// Vulkan does not permit recursion (Vulkan spec Appendix A):
// "Recursion: The static function-call graph for an entry point must not
// contain cycles."
return SPV_REFLECT_RESULT_ERROR_SPIRV_RECURSION;
}
if (IsNotNull(p_func_ids)) {
p_func_ids[(*p_func_count)++] = p_func->id;
} else {
++*p_func_count;
}
for (size_t i = 0; i < p_func->callee_count; ++i) {
SpvReflectResult result = TraverseCallGraph(
p_parser, p_func->callee_ptrs[i], p_func_count, p_func_ids, depth + 1);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseStaticallyUsedResources(
Parser* p_parser,
SpvReflectShaderModule* p_module,
SpvReflectEntryPoint* p_entry,
size_t uniform_count,
uint32_t* uniforms,
size_t push_constant_count,
uint32_t* push_constants
)
{
// Find function with the right id
Function* p_func = NULL;
for (size_t i = 0; i < p_parser->function_count; ++i) {
if (p_parser->functions[i].id == p_entry->id) {
p_func = &(p_parser->functions[i]);
break;
}
}
if (p_func == NULL) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
size_t called_function_count = 0;
SpvReflectResult result = TraverseCallGraph(
p_parser,
p_func,
&called_function_count,
NULL,
0);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
uint32_t* p_called_functions = NULL;
if (called_function_count > 0) {
p_called_functions = (uint32_t*)calloc(called_function_count, sizeof(*p_called_functions));
if (IsNull(p_called_functions)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
called_function_count = 0;
result = TraverseCallGraph(
p_parser,
p_func,
&called_function_count,
p_called_functions,
0);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
if (called_function_count > 0) {
qsort(
p_called_functions,
called_function_count,
sizeof(*p_called_functions),
SortCompareUint32);
}
called_function_count = DedupSortedUint32(p_called_functions, called_function_count);
uint32_t used_variable_count = 0;
for (size_t i = 0, j = 0; i < called_function_count; ++i) {
// No need to bounds check j because a missing ID issue would have been
// found during TraverseCallGraph
while (p_parser->functions[j].id != p_called_functions[i]) {
++j;
}
used_variable_count += p_parser->functions[j].accessed_ptr_count;
}
uint32_t* used_variables = NULL;
if (used_variable_count > 0) {
used_variables = (uint32_t*)calloc(used_variable_count,
sizeof(*used_variables));
if (IsNull(used_variables)) {
SafeFree(p_called_functions);
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
used_variable_count = 0;
for (size_t i = 0, j = 0; i < called_function_count; ++i) {
while (p_parser->functions[j].id != p_called_functions[i]) {
++j;
}
memcpy(&used_variables[used_variable_count],
p_parser->functions[j].accessed_ptrs,
p_parser->functions[j].accessed_ptr_count * sizeof(*used_variables));
used_variable_count += p_parser->functions[j].accessed_ptr_count;
}
SafeFree(p_called_functions);
if (used_variable_count > 0) {
qsort(used_variables, used_variable_count, sizeof(*used_variables),
SortCompareUint32);
}
used_variable_count = (uint32_t)DedupSortedUint32(used_variables,
used_variable_count);
// Do set intersection to find the used uniform and push constants
size_t used_uniform_count = 0;
//
SpvReflectResult result0 = IntersectSortedUint32(
used_variables,
used_variable_count,
uniforms,
uniform_count,
&p_entry->used_uniforms,
&used_uniform_count);
size_t used_push_constant_count = 0;
//
SpvReflectResult result1 = IntersectSortedUint32(
used_variables,
used_variable_count,
push_constants,
push_constant_count,
&p_entry->used_push_constants,
&used_push_constant_count);
for (uint32_t j = 0; j < p_module->descriptor_binding_count; ++j) {
SpvReflectDescriptorBinding* p_binding = &p_module->descriptor_bindings[j];
bool found = SearchSortedUint32(
used_variables,
used_variable_count,
p_binding->spirv_id);
if (found) {
p_binding->accessed = 1;
}
}
SafeFree(used_variables);
if (result0 != SPV_REFLECT_RESULT_SUCCESS) {
return result0;
}
if (result1 != SPV_REFLECT_RESULT_SUCCESS) {
return result1;
}
p_entry->used_uniform_count = (uint32_t)used_uniform_count;
p_entry->used_push_constant_count = (uint32_t)used_push_constant_count;
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModule* p_module)
{
if (p_parser->entry_point_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
p_module->entry_point_count = p_parser->entry_point_count;
p_module->entry_points = (SpvReflectEntryPoint*)calloc(p_module->entry_point_count,
sizeof(*(p_module->entry_points)));
if (IsNull(p_module->entry_points)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
SpvReflectResult result;
size_t uniform_count = 0;
uint32_t* uniforms = NULL;
if ((result = EnumerateAllUniforms(p_module, &uniform_count, &uniforms)) !=
SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
size_t push_constant_count = 0;
uint32_t* push_constants = NULL;
if ((result = EnumerateAllPushConstants(p_module, &push_constant_count, &push_constants)) !=
SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
size_t entry_point_index = 0;
for (size_t i = 0; entry_point_index < p_parser->entry_point_count && i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if (p_node->op != SpvOpEntryPoint) {
continue;
}
SpvReflectEntryPoint* p_entry_point = &(p_module->entry_points[entry_point_index]);
CHECKED_READU32_CAST(p_parser, p_node->word_offset + 1, SpvExecutionModel, p_entry_point->spirv_execution_model);
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_entry_point->id);
switch (p_entry_point->spirv_execution_model) {
default: break;
case SpvExecutionModelVertex : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_VERTEX_BIT; break;
case SpvExecutionModelTessellationControl : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TESSELLATION_CONTROL_BIT; break;
case SpvExecutionModelTessellationEvaluation : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; break;
case SpvExecutionModelGeometry : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_GEOMETRY_BIT; break;
case SpvExecutionModelFragment : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_FRAGMENT_BIT; break;
case SpvExecutionModelGLCompute : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_COMPUTE_BIT; break;
}
++entry_point_index;
// Name length is required to calculate next operand
uint32_t name_start_word_offset = 3;
uint32_t name_length_with_terminator = 0;
result = ReadStr(p_parser, p_node->word_offset + name_start_word_offset, 0, p_node->word_count, &name_length_with_terminator, NULL);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
p_entry_point->name = (const char*)(p_parser->spirv_code + p_node->word_offset + name_start_word_offset);
uint32_t name_word_count = RoundUp(name_length_with_terminator, SPIRV_WORD_SIZE) / SPIRV_WORD_SIZE;
size_t interface_variable_count = (p_node->word_count - (name_start_word_offset + name_word_count));
uint32_t* interface_variables = NULL;
if (interface_variable_count > 0) {
interface_variables = (uint32_t*)calloc(interface_variable_count, sizeof(*(interface_variables)));
if (IsNull(interface_variables)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
for (uint32_t var_index = 0; var_index < interface_variable_count; ++var_index) {
uint32_t var_result_id = (uint32_t)INVALID_VALUE;
uint32_t offset = name_start_word_offset + name_word_count + var_index;
CHECKED_READU32(p_parser, p_node->word_offset + offset, var_result_id);
interface_variables[var_index] = var_result_id;
}
result = ParseInterfaceVariables(
p_parser,
p_module,
p_entry_point,
interface_variable_count,
interface_variables);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
SafeFree(interface_variables);
result = ParseStaticallyUsedResources(
p_parser,
p_module,
p_entry_point,
uniform_count,
uniforms,
push_constant_count,
push_constants);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
}
SafeFree(uniforms);
SafeFree(push_constants);
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParsePushConstantBlocks(Parser* p_parser, SpvReflectShaderModule* p_module)
{
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if ((p_node->op != SpvOpVariable) || (p_node->storage_class != SpvStorageClassPushConstant)) {
continue;
}
p_module->push_constant_block_count += 1;
}
if (p_module->push_constant_block_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
p_module->push_constant_blocks = (SpvReflectBlockVariable*)calloc(p_module->push_constant_block_count, sizeof(*p_module->push_constant_blocks));
if (IsNull(p_module->push_constant_blocks)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
uint32_t push_constant_index = 0;
for (size_t i = 0; i < p_parser->node_count; ++i) {
Node* p_node = &(p_parser->nodes[i]);
if ((p_node->op != SpvOpVariable) || (p_node->storage_class != SpvStorageClassPushConstant)) {
continue;
}
SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
if (IsNull(p_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// If the type is a pointer, resolve it
if (p_type->op == SpvOpTypePointer) {
// Find the type's node
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
// Should be the resolved type
p_type = FindType(p_module, p_type_node->type_id);
if (IsNull(p_type)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
}
Node* p_type_node = FindNode(p_parser, p_type->id);
if (IsNull(p_type_node)) {
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
}
SpvReflectBlockVariable* p_push_constant = &p_module->push_constant_blocks[push_constant_index];
p_push_constant->spirv_id = p_node->result_id;
SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_type, p_push_constant);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
result = ParseDescriptorBlockVariableSizes(p_parser, p_module, true, false, false, p_push_constant);
if (result != SPV_REFLECT_RESULT_SUCCESS) {
return result;
}
++push_constant_index;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static int SortCompareDescriptorSet(const void* a, const void* b)
{
const SpvReflectDescriptorSet* p_elem_a = (const SpvReflectDescriptorSet*)a;
const SpvReflectDescriptorSet* p_elem_b = (const SpvReflectDescriptorSet*)b;
int value = (int)(p_elem_a->set) - (int)(p_elem_b->set);
// We should never see duplicate descriptor set numbers in a shader; if so, a tiebreaker
// would be needed here.
assert(value != 0);
return value;
}
static SpvReflectResult ParseEntrypointDescriptorSets(SpvReflectShaderModule* p_module) {
// Update the entry point's sets
for (uint32_t i = 0; i < p_module->entry_point_count; ++i) {
SpvReflectEntryPoint* p_entry = &p_module->entry_points[i];
for (uint32_t j = 0; j < p_entry->descriptor_set_count; ++j) {
SafeFree(p_entry->descriptor_sets[j].bindings);
}
SafeFree(p_entry->descriptor_sets);
p_entry->descriptor_set_count = 0;
for (uint32_t j = 0; j < p_module->descriptor_set_count; ++j) {
const SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[j];
for (uint32_t k = 0; k < p_set->binding_count; ++k) {
bool found = SearchSortedUint32(
p_entry->used_uniforms,
p_entry->used_uniform_count,
p_set->bindings[k]->spirv_id);
if (found) {
++p_entry->descriptor_set_count;
break;
}
}
}
p_entry->descriptor_sets = NULL;
if (p_entry->descriptor_set_count > 0) {
p_entry->descriptor_sets = (SpvReflectDescriptorSet*)calloc(p_entry->descriptor_set_count,
sizeof(*p_entry->descriptor_sets));
if (IsNull(p_entry->descriptor_sets)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
}
p_entry->descriptor_set_count = 0;
for (uint32_t j = 0; j < p_module->descriptor_set_count; ++j) {
const SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[j];
uint32_t count = 0;
for (uint32_t k = 0; k < p_set->binding_count; ++k) {
bool found = SearchSortedUint32(
p_entry->used_uniforms,
p_entry->used_uniform_count,
p_set->bindings[k]->spirv_id);
if (found) {
++count;
}
}
if (count == 0) {
continue;
}
SpvReflectDescriptorSet* p_entry_set = &p_entry->descriptor_sets[
p_entry->descriptor_set_count++];
p_entry_set->set = p_set->set;
p_entry_set->bindings = (SpvReflectDescriptorBinding**)calloc(count,
sizeof(*p_entry_set->bindings));
if (IsNull(p_entry_set->bindings)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
for (uint32_t k = 0; k < p_set->binding_count; ++k) {
bool found = SearchSortedUint32(
p_entry->used_uniforms,
p_entry->used_uniform_count,
p_set->bindings[k]->spirv_id);
if (found) {
p_entry_set->bindings[p_entry_set->binding_count++] = p_set->bindings[k];
}
}
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult ParseDescriptorSets(SpvReflectShaderModule* p_module)
{
// Count the descriptors in each set
for (uint32_t i = 0; i < p_module->descriptor_binding_count; ++i) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[i]);
// Look for a target set using the descriptor's set number
SpvReflectDescriptorSet* p_target_set = NULL;
for (uint32_t j = 0; j < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++j) {
SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[j];
if (p_set->set == p_descriptor->set) {
p_target_set = p_set;
break;
}
}
// If a target set isn't found, find the first available one.
if (IsNull(p_target_set)) {
for (uint32_t j = 0; j < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++j) {
SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[j];
if (p_set->set == (uint32_t)INVALID_VALUE) {
p_target_set = p_set;
p_target_set->set = p_descriptor->set;
break;
}
}
}
if (IsNull(p_target_set)) {
return SPV_REFLECT_RESULT_ERROR_INTERNAL_ERROR;
}
p_target_set->binding_count += 1;
}
// Count the descriptor sets
for (uint32_t i = 0; i < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++i) {
const SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[i];
if (p_set->set != (uint32_t)INVALID_VALUE) {
p_module->descriptor_set_count += 1;
}
}
// Sort the descriptor sets based on numbers
if (p_module->descriptor_set_count > 0) {
qsort(p_module->descriptor_sets,
p_module->descriptor_set_count,
sizeof(*(p_module->descriptor_sets)),
SortCompareDescriptorSet);
}
// Build descriptor pointer array
for (uint32_t i = 0; i <p_module->descriptor_set_count; ++i) {
SpvReflectDescriptorSet* p_set = &(p_module->descriptor_sets[i]);
p_set->bindings = (SpvReflectDescriptorBinding **)calloc(p_set->binding_count, sizeof(*(p_set->bindings)));
uint32_t descriptor_index = 0;
for (uint32_t j = 0; j < p_module->descriptor_binding_count; ++j) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[j]);
if (p_descriptor->set == p_set->set) {
assert(descriptor_index < p_set->binding_count);
p_set->bindings[descriptor_index] = p_descriptor;
++descriptor_index;
}
}
}
return ParseEntrypointDescriptorSets(p_module);
}
static SpvReflectResult DisambiguateStorageBufferSrvUav(SpvReflectShaderModule* p_module)
{
if (p_module->descriptor_binding_count == 0) {
return SPV_REFLECT_RESULT_SUCCESS;
}
for (uint32_t descriptor_index = 0; descriptor_index < p_module->descriptor_binding_count; ++descriptor_index) {
SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[descriptor_index]);
// Skip everything that isn't a STORAGE_BUFFER descriptor
if (p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
continue;
}
//
// Vulkan doesn't disambiguate between SRVs and UAVs so they
// come back as STORAGE_BUFFER. The block parsing process will
// mark a block as non-writable should any member of the block
// or its descendants are non-writable.
//
if (p_descriptor->block.decoration_flags & SPV_REFLECT_DECORATION_NON_WRITABLE) {
p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV;
}
}
return SPV_REFLECT_RESULT_SUCCESS;
}
static SpvReflectResult SynchronizeDescriptorSets(SpvReflectShaderModule* p_module)
{
// Free and reset all descriptor set numbers
for (uint32_t i = 0; i < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++i) {
SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[i];
SafeFree(p_set->bindings);
p_set->binding_count = 0;
p_set->set = (uint32_t)INVALID_VALUE;
}
// Set descriptor set count to zero
p_module->descriptor_set_count = 0;
SpvReflectResult result = ParseDescriptorSets(p_module);
return result;
}
SpvReflectResult spvReflectGetShaderModule(
size_t size,
const void* p_code,
SpvReflectShaderModule* p_module
)
{
return spvReflectCreateShaderModule(size, p_code, p_module);
}
SpvReflectResult spvReflectCreateShaderModule(
size_t size,
const void* p_code,
SpvReflectShaderModule* p_module
)
{
// Initialize all module fields to zero
memset(p_module, 0, sizeof(*p_module));
// Allocate module internals
#ifdef __cplusplus
p_module->_internal = (SpvReflectShaderModule::Internal*)calloc(1, sizeof(*(p_module->_internal)));
#else
p_module->_internal = calloc(1, sizeof(*(p_module->_internal)));
#endif
if (IsNull(p_module->_internal)) {
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
// Allocate SPIR-V code storage
p_module->_internal->spirv_size = size;
p_module->_internal->spirv_code = (uint32_t*)calloc(1, p_module->_internal->spirv_size);
p_module->_internal->spirv_word_count = (uint32_t)(size / SPIRV_WORD_SIZE);
if (IsNull(p_module->_internal->spirv_code)) {
SafeFree(p_module->_internal);
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
}
memcpy(p_module->_internal->spirv_code, p_code, size);
Parser parser = { 0 };
SpvReflectResult result = CreateParser(p_module->_internal->spirv_size,
p_module->_internal->spirv_code,
&parser);
// Generator
{
const uint32_t* p_ptr = (const uint32_t*)p_module->_internal->spirv_code;
p_module->generator = (SpvReflectGenerator)((*(p_ptr + 2) & 0xFFFF0000) >> 16);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseNodes(&parser);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseStrings(&parser);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseSource(&parser, p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseFunctions(&parser);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseMemberCounts(&parser);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseNames(&parser);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseDecorations(&parser);
}
// Start of reflection data parsing
if (result == SPV_REFLECT_RESULT_SUCCESS) {
p_module->source_language = parser.source_language;
p_module->source_language_version = parser.source_language_version;
// Zero out descriptor set data
p_module->descriptor_set_count = 0;
memset(p_module->descriptor_sets, 0, SPV_REFLECT_MAX_DESCRIPTOR_SETS * sizeof(*p_module->descriptor_sets));
// Initialize descriptor set numbers
for (uint32_t set_number = 0; set_number < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++set_number) {
p_module->descriptor_sets[set_number].set = (uint32_t)INVALID_VALUE;
}
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseTypes(&parser, p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseDescriptorBindings(&parser, p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseDescriptorType(p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseUAVCounterBindings(p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseDescriptorBlocks(&parser, p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParsePushConstantBlocks(&parser, p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = ParseEntryPoints(&parser, p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS && p_module->entry_point_count > 0) {
SpvReflectEntryPoint* p_entry = &(p_module->entry_points[0]);
p_module->entry_point_name = p_entry->name;
p_module->entry_point_id = p_entry->id;
p_module->spirv_execution_model = p_entry->spirv_execution_model;
p_module->shader_stage = p_entry->shader_stage;
p_module->input_variable_count = p_entry->input_variable_count;
p_module->input_variables = p_entry->input_variables;
p_module->output_variable_count = p_entry->output_variable_count;
p_module->output_variables = p_entry->output_variables;
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = DisambiguateStorageBufferSrvUav(p_module);
}
if (result == SPV_REFLECT_RESULT_SUCCESS) {
result = SynchronizeDescriptorSets(p_module);
}
// Destroy module if parse was not successful
if (result != SPV_REFLECT_RESULT_SUCCESS) {
spvReflectDestroyShaderModule(p_module);
}
DestroyParser(&parser);
return result;
}
static void SafeFreeTypes(SpvReflectTypeDescription* p_type)
{
if (IsNull(p_type)) {
return;
}
if (IsNotNull(p_type->members)) {
for (size_t i = 0; i < p_type->member_count; ++i) {
SpvReflectTypeDescription* p_member = &p_type->members[i];
SafeFreeTypes(p_member);
}
SafeFree(p_type->members);
p_type->members = NULL;
}
}
static void SafeFreeBlockVariables(SpvReflectBlockVariable* p_block)
{
if (IsNull(p_block)) {
return;
}
if (IsNotNull(p_block->members)) {
for (size_t i = 0; i < p_block->member_count; ++i) {
SpvReflectBlockVariable* p_member = &p_block->members[i];
SafeFreeBlockVariables(p_member);
}
SafeFree(p_block->members);
p_block->members = NULL;
}
}
static void SafeFreeInterfaceVariable(SpvReflectInterfaceVariable* p_interface)
{
if (IsNull(p_interface)) {
return;
}
if (IsNotNull(p_interface->members)) {
for (size_t i = 0; i < p_interface->member_count; ++i) {
SpvReflectInterfaceVariable* p_member = &p_interface->members[i];
SafeFreeInterfaceVariable(p_member);
}
SafeFree(p_interface->members);
p_interface->members = NULL;
}
}
void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module)
{
if (IsNull(p_module->_internal)) {
return;
}
// Descriptor set bindings
for (size_t i = 0; i < p_module->descriptor_set_count; ++i) {
SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[i];
free(p_set->bindings);
}
// Descriptor binding blocks
for (size_t i = 0; i < p_module->descriptor_binding_count; ++i) {
SpvReflectDescriptorBinding* p_descriptor = &p_module->descriptor_bindings[i];
SafeFreeBlockVariables(&p_descriptor->block);
}
SafeFree(p_module->descriptor_bindings);
// Entry points
for (size_t i = 0; i < p_module->entry_point_count; ++i) {
SpvReflectEntryPoint* p_entry = &p_module->entry_points[i];
for (size_t j = 0; j < p_entry->input_variable_count; j++) {
SafeFreeInterfaceVariable(&p_entry->input_variables[j]);
}
for (size_t j = 0; j < p_entry->output_variable_count; j++) {
SafeFreeInterfaceVariable(&p_entry->output_variables[j]);
}
for (uint32_t j = 0; j < p_entry->descriptor_set_count; ++j) {
SafeFree(p_entry->descriptor_sets[j].bindings);
}
SafeFree(p_entry->descriptor_sets);
SafeFree(p_entry->input_variables);
SafeFree(p_entry->output_variables);
SafeFree(p_entry->used_uniforms);
SafeFree(p_entry->used_push_constants);
}
SafeFree(p_module->entry_points);
// Push constants
for (size_t i = 0; i < p_module->push_constant_block_count; ++i) {
SafeFreeBlockVariables(&p_module->push_constant_blocks[i]);
}
SafeFree(p_module->push_constant_blocks);
// Type infos
for (size_t i = 0; i < p_module->_internal->type_description_count; ++i) {
SpvReflectTypeDescription* p_type = &p_module->_internal->type_descriptions[i];
if (IsNotNull(p_type->members)) {
SafeFreeTypes(p_type);
}
SafeFree(p_type->members);
}
SafeFree(p_module->_internal->type_descriptions);
// Free SPIR-V code
SafeFree(p_module->_internal->spirv_code);
// Free internal
SafeFree(p_module->_internal);
}
uint32_t spvReflectGetCodeSize(const SpvReflectShaderModule* p_module)
{
if (IsNull(p_module)) {
return 0;
}
return (uint32_t)(p_module->_internal->spirv_size);
}
const uint32_t* spvReflectGetCode(const SpvReflectShaderModule* p_module)
{
if (IsNull(p_module)) {
return NULL;
}
return p_module->_internal->spirv_code;
}
const SpvReflectEntryPoint* spvReflectGetEntryPoint(
const SpvReflectShaderModule* p_module,
const char* entry_point
) {
if (IsNull(p_module) || IsNull(entry_point)) {
return NULL;
}
for (uint32_t i = 0; i < p_module->entry_point_count; ++i) {
if (strcmp(p_module->entry_points[i].name, entry_point) == 0) {
return &p_module->entry_points[i];
}
}
return NULL;
}
SpvReflectResult spvReflectEnumerateDescriptorBindings(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectDescriptorBinding** pp_bindings
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNotNull(pp_bindings)) {
if (*p_count != p_module->descriptor_binding_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectDescriptorBinding* p_bindings = (SpvReflectDescriptorBinding*)&p_module->descriptor_bindings[index];
pp_bindings[index] = p_bindings;
}
}
else {
*p_count = p_module->descriptor_binding_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateEntryPointDescriptorBindings(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectDescriptorBinding** pp_bindings
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
uint32_t count = 0;
for (uint32_t i = 0; i < p_module->descriptor_binding_count; ++i) {
bool found = SearchSortedUint32(
p_entry->used_uniforms,
p_entry->used_uniform_count,
p_module->descriptor_bindings[i].spirv_id);
if (found) {
if (IsNotNull(pp_bindings)) {
if (count >= *p_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
pp_bindings[count++] = (SpvReflectDescriptorBinding*)&p_module->descriptor_bindings[i];
} else {
++count;
}
}
}
if (IsNotNull(pp_bindings)) {
if (count != *p_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
} else {
*p_count = count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateDescriptorSets(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectDescriptorSet** pp_sets
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNotNull(pp_sets)) {
if (*p_count != p_module->descriptor_set_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectDescriptorSet* p_set = (SpvReflectDescriptorSet*)&p_module->descriptor_sets[index];
pp_sets[index] = p_set;
}
}
else {
*p_count = p_module->descriptor_set_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateEntryPointDescriptorSets(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectDescriptorSet** pp_sets
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
if (IsNotNull(pp_sets)) {
if (*p_count != p_entry->descriptor_set_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectDescriptorSet* p_set = (SpvReflectDescriptorSet*)&p_entry->descriptor_sets[index];
pp_sets[index] = p_set;
}
}
else {
*p_count = p_entry->descriptor_set_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateInputVariables(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNotNull(pp_variables)) {
if (*p_count != p_module->input_variable_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectInterfaceVariable* p_var = (SpvReflectInterfaceVariable*)&p_module->input_variables[index];
pp_variables[index] = p_var;
}
}
else {
*p_count = p_module->input_variable_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateEntryPointInputVariables(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
if (IsNotNull(pp_variables)) {
if (*p_count != p_entry->input_variable_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectInterfaceVariable* p_var = (SpvReflectInterfaceVariable*)&p_entry->input_variables[index];
pp_variables[index] = p_var;
}
}
else {
*p_count = p_entry->input_variable_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateOutputVariables(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNotNull(pp_variables)) {
if (*p_count != p_module->output_variable_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectInterfaceVariable* p_var = (SpvReflectInterfaceVariable*)&p_module->output_variables[index];
pp_variables[index] = p_var;
}
}
else {
*p_count = p_module->output_variable_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumerateEntryPointOutputVariables(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
if (IsNotNull(pp_variables)) {
if (*p_count != p_entry->output_variable_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectInterfaceVariable* p_var = (SpvReflectInterfaceVariable*)&p_entry->output_variables[index];
pp_variables[index] = p_var;
}
}
else {
*p_count = p_entry->output_variable_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumeratePushConstantBlocks(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectBlockVariable** pp_blocks
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (pp_blocks != NULL) {
if (*p_count != p_module->push_constant_block_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
for (uint32_t index = 0; index < *p_count; ++index) {
SpvReflectBlockVariable* p_push_constant_blocks = (SpvReflectBlockVariable*)&p_module->push_constant_blocks[index];
pp_blocks[index] = p_push_constant_blocks;
}
}
else {
*p_count = p_module->push_constant_block_count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectEnumeratePushConstants(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectBlockVariable** pp_blocks
)
{
return spvReflectEnumeratePushConstantBlocks(p_module, p_count, pp_blocks);
}
SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectBlockVariable** pp_blocks
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_count)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
uint32_t count = 0;
for (uint32_t i = 0; i < p_module->push_constant_block_count; ++i) {
bool found = SearchSortedUint32(p_entry->used_push_constants,
p_entry->used_push_constant_count,
p_module->push_constant_blocks[i].spirv_id);
if (found) {
if (IsNotNull(pp_blocks)) {
if (count >= *p_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
pp_blocks[count++] = (SpvReflectBlockVariable*)&p_module->push_constant_blocks[i];
} else {
++count;
}
}
}
if (IsNotNull(pp_blocks)) {
if (count != *p_count) {
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
}
} else {
*p_count = count;
}
return SPV_REFLECT_RESULT_SUCCESS;
}
const SpvReflectDescriptorBinding* spvReflectGetDescriptorBinding(
const SpvReflectShaderModule* p_module,
uint32_t binding_number,
uint32_t set_number,
SpvReflectResult* p_result
)
{
const SpvReflectDescriptorBinding* p_descriptor = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->descriptor_binding_count; ++index) {
const SpvReflectDescriptorBinding* p_potential = &p_module->descriptor_bindings[index];
if ((p_potential->binding == binding_number) && (p_potential->set == set_number)) {
p_descriptor = p_potential;
break;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_descriptor)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_descriptor;
}
const SpvReflectDescriptorBinding* spvReflectGetEntryPointDescriptorBinding(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t binding_number,
uint32_t set_number,
SpvReflectResult* p_result
)
{
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectDescriptorBinding* p_descriptor = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->descriptor_binding_count; ++index) {
const SpvReflectDescriptorBinding* p_potential = &p_module->descriptor_bindings[index];
bool found = SearchSortedUint32(
p_entry->used_uniforms,
p_entry->used_uniform_count,
p_potential->spirv_id);
if ((p_potential->binding == binding_number) && (p_potential->set == set_number) && found) {
p_descriptor = p_potential;
break;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_descriptor)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_descriptor;
}
const SpvReflectDescriptorSet* spvReflectGetDescriptorSet(
const SpvReflectShaderModule* p_module,
uint32_t set_number,
SpvReflectResult* p_result
)
{
const SpvReflectDescriptorSet* p_set = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->descriptor_set_count; ++index) {
const SpvReflectDescriptorSet* p_potential = &p_module->descriptor_sets[index];
if (p_potential->set == set_number) {
p_set = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_set)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_set;
}
const SpvReflectDescriptorSet* spvReflectGetEntryPointDescriptorSet(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t set_number,
SpvReflectResult* p_result)
{
const SpvReflectDescriptorSet* p_set = NULL;
if (IsNotNull(p_module)) {
const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
for (uint32_t index = 0; index < p_entry->descriptor_set_count; ++index) {
const SpvReflectDescriptorSet* p_potential = &p_entry->descriptor_sets[index];
if (p_potential->set == set_number) {
p_set = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_set)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_set;
}
const SpvReflectInterfaceVariable* spvReflectGetInputVariableByLocation(
const SpvReflectShaderModule* p_module,
uint32_t location,
SpvReflectResult* p_result
)
{
if (location == INVALID_VALUE) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->input_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_module->input_variables[index];
if (p_potential->location == location) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetInputVariable(
const SpvReflectShaderModule* p_module,
uint32_t location,
SpvReflectResult* p_result
)
{
return spvReflectGetInputVariableByLocation(p_module, location, p_result);
}
const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableByLocation(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t location,
SpvReflectResult* p_result
)
{
if (location == INVALID_VALUE) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
for (uint32_t index = 0; index < p_entry->input_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_entry->input_variables[index];
if (p_potential->location == location) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetInputVariableBySemantic(
const SpvReflectShaderModule* p_module,
const char* semantic,
SpvReflectResult* p_result
)
{
if (IsNull(semantic)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
return NULL;
}
if (semantic[0] == '\0') {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->input_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_module->input_variables[index];
if (p_potential->semantic != NULL && strcmp(p_potential->semantic, semantic) == 0) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableBySemantic(
const SpvReflectShaderModule* p_module,
const char* entry_point,
const char* semantic,
SpvReflectResult* p_result
)
{
if (IsNull(semantic)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
return NULL;
}
if (semantic[0] == '\0') {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
for (uint32_t index = 0; index < p_entry->input_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_entry->input_variables[index];
if (p_potential->semantic != NULL && strcmp(p_potential->semantic, semantic) == 0) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetOutputVariableByLocation(
const SpvReflectShaderModule* p_module,
uint32_t location,
SpvReflectResult* p_result
)
{
if (location == INVALID_VALUE) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->output_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_module->output_variables[index];
if (p_potential->location == location) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetOutputVariable(
const SpvReflectShaderModule* p_module,
uint32_t location,
SpvReflectResult* p_result
)
{
return spvReflectGetOutputVariableByLocation(p_module, location, p_result);
}
const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableByLocation(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t location,
SpvReflectResult* p_result
)
{
if (location == INVALID_VALUE) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
for (uint32_t index = 0; index < p_entry->output_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_entry->output_variables[index];
if (p_potential->location == location) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetOutputVariableBySemantic(
const SpvReflectShaderModule* p_module,
const char* semantic,
SpvReflectResult* p_result
)
{
if (IsNull(semantic)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
return NULL;
}
if (semantic[0] == '\0') {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
for (uint32_t index = 0; index < p_module->output_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_module->output_variables[index];
if (p_potential->semantic != NULL && strcmp(p_potential->semantic, semantic) == 0) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableBySemantic(
const SpvReflectShaderModule* p_module,
const char* entry_point,
const char* semantic,
SpvReflectResult* p_result)
{
if (IsNull(semantic)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
return NULL;
}
if (semantic[0] == '\0') {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
const SpvReflectInterfaceVariable* p_var = NULL;
if (IsNotNull(p_module)) {
const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
for (uint32_t index = 0; index < p_entry->output_variable_count; ++index) {
const SpvReflectInterfaceVariable* p_potential = &p_entry->output_variables[index];
if (p_potential->semantic != NULL && strcmp(p_potential->semantic, semantic) == 0) {
p_var = p_potential;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_var)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_var;
}
const SpvReflectBlockVariable* spvReflectGetPushConstantBlock(
const SpvReflectShaderModule* p_module,
uint32_t index,
SpvReflectResult* p_result
)
{
const SpvReflectBlockVariable* p_push_constant = NULL;
if (IsNotNull(p_module)) {
if (index < p_module->push_constant_block_count) {
p_push_constant = &p_module->push_constant_blocks[index];
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_push_constant)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_push_constant;
}
const SpvReflectBlockVariable* spvReflectGetPushConstant(
const SpvReflectShaderModule* p_module,
uint32_t index,
SpvReflectResult* p_result
)
{
return spvReflectGetPushConstantBlock(p_module, index, p_result);
}
const SpvReflectBlockVariable* spvReflectGetEntryPointPushConstantBlock(
const SpvReflectShaderModule* p_module,
const char* entry_point,
SpvReflectResult* p_result)
{
const SpvReflectBlockVariable* p_push_constant = NULL;
if (IsNotNull(p_module)) {
const SpvReflectEntryPoint* p_entry =
spvReflectGetEntryPoint(p_module, entry_point);
if (IsNull(p_entry)) {
if (IsNotNull(p_result)) {
*p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
return NULL;
}
for (uint32_t i = 0; i < p_module->push_constant_block_count; ++i) {
bool found = SearchSortedUint32(
p_entry->used_push_constants,
p_entry->used_push_constant_count,
p_module->push_constant_blocks[i].spirv_id);
if (found) {
p_push_constant = &p_module->push_constant_blocks[i];
break;
}
}
}
if (IsNotNull(p_result)) {
*p_result = IsNotNull(p_push_constant)
? SPV_REFLECT_RESULT_SUCCESS
: (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
: SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
}
return p_push_constant;
}
SpvReflectResult spvReflectChangeDescriptorBindingNumbers(
SpvReflectShaderModule* p_module,
const SpvReflectDescriptorBinding* p_binding,
uint32_t new_binding_number,
uint32_t new_set_binding
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_binding)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
SpvReflectDescriptorBinding* p_target_descriptor = NULL;
for (uint32_t index = 0; index < p_module->descriptor_binding_count; ++index) {
if(&p_module->descriptor_bindings[index] == p_binding) {
p_target_descriptor = &p_module->descriptor_bindings[index];
break;
}
}
if (IsNotNull(p_target_descriptor)) {
if (p_target_descriptor->word_offset.binding > (p_module->_internal->spirv_word_count - 1)) {
return SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED;
}
// Binding number
if (new_binding_number != SPV_REFLECT_BINDING_NUMBER_DONT_CHANGE) {
uint32_t* p_code = p_module->_internal->spirv_code + p_target_descriptor->word_offset.binding;
*p_code = new_binding_number;
p_target_descriptor->binding = new_binding_number;
}
// Set number
if (new_set_binding != SPV_REFLECT_SET_NUMBER_DONT_CHANGE) {
uint32_t* p_code = p_module->_internal->spirv_code + p_target_descriptor->word_offset.set;
*p_code = new_set_binding;
p_target_descriptor->set = new_set_binding;
}
}
SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
if (new_set_binding != SPV_REFLECT_SET_NUMBER_DONT_CHANGE) {
result = SynchronizeDescriptorSets(p_module);
}
return result;
}
SpvReflectResult spvReflectChangeDescriptorBindingNumber(
SpvReflectShaderModule* p_module,
const SpvReflectDescriptorBinding* p_descriptor_binding,
uint32_t new_binding_number,
uint32_t optional_new_set_number
)
{
return spvReflectChangeDescriptorBindingNumbers(
p_module,p_descriptor_binding,
new_binding_number,
optional_new_set_number);
}
SpvReflectResult spvReflectChangeDescriptorSetNumber(
SpvReflectShaderModule* p_module,
const SpvReflectDescriptorSet* p_set,
uint32_t new_set_number
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_set)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
SpvReflectDescriptorSet* p_target_set = NULL;
for (uint32_t index = 0; index < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++index) {
// The descriptor sets for specific entry points might not be in this set,
// so just match on set index.
if (p_module->descriptor_sets[index].set == p_set->set) {
p_target_set = (SpvReflectDescriptorSet*)p_set;
break;
}
}
SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
if (IsNotNull(p_target_set) && new_set_number != SPV_REFLECT_SET_NUMBER_DONT_CHANGE) {
for (uint32_t index = 0; index < p_target_set->binding_count; ++index) {
SpvReflectDescriptorBinding* p_descriptor = p_target_set->bindings[index];
if (p_descriptor->word_offset.set > (p_module->_internal->spirv_word_count - 1)) {
return SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED;
}
uint32_t* p_code = p_module->_internal->spirv_code + p_descriptor->word_offset.set;
*p_code = new_set_number;
p_descriptor->set = new_set_number;
}
result = SynchronizeDescriptorSets(p_module);
}
return result;
}
static SpvReflectResult ChangeVariableLocation(
SpvReflectShaderModule* p_module,
SpvReflectInterfaceVariable* p_variable,
uint32_t new_location
)
{
if (p_variable->word_offset.location > (p_module->_internal->spirv_word_count - 1)) {
return SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED;
}
uint32_t* p_code = p_module->_internal->spirv_code + p_variable->word_offset.location;
*p_code = new_location;
p_variable->location = new_location;
return SPV_REFLECT_RESULT_SUCCESS;
}
SpvReflectResult spvReflectChangeInputVariableLocation(
SpvReflectShaderModule* p_module,
const SpvReflectInterfaceVariable* p_input_variable,
uint32_t new_location
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_input_variable)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
for (uint32_t index = 0; index < p_module->input_variable_count; ++index) {
if(&p_module->input_variables[index] == p_input_variable) {
return ChangeVariableLocation(p_module, &p_module->input_variables[index], new_location);
}
}
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
SpvReflectResult spvReflectChangeOutputVariableLocation(
SpvReflectShaderModule* p_module,
const SpvReflectInterfaceVariable* p_output_variable,
uint32_t new_location
)
{
if (IsNull(p_module)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
if (IsNull(p_output_variable)) {
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
}
for (uint32_t index = 0; index < p_module->output_variable_count; ++index) {
if(&p_module->output_variables[index] == p_output_variable) {
return ChangeVariableLocation(p_module, &p_module->output_variables[index], new_location);
}
}
return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
}
const char* spvReflectSourceLanguage(SpvSourceLanguage source_lang)
{
switch (source_lang) {
case SpvSourceLanguageUnknown : return "Unknown";
case SpvSourceLanguageESSL : return "ESSL";
case SpvSourceLanguageGLSL : return "GLSL";
case SpvSourceLanguageOpenCL_C : return "OpenCL_C";
case SpvSourceLanguageOpenCL_CPP : return "OpenCL_CPP";
case SpvSourceLanguageHLSL : return "HLSL";
case SpvSourceLanguageMax:
break;
}
return "";
}
Reference in New Issue View Git Blame Copy Permalink