Adding preliminary SpecConstant support

CMakeLists.txt

@@ -8,6 +8,7 @@ OPTION(SPIRV_REFLECT_STRIPPER       "Build stripper utility" OFF)
 OPTION(SPIRV_REFLECT_STATIC_LIB     "Build a SPIRV-Reflect static library" OFF)
 OPTION(SPIRV_REFLECT_BUILD_TESTS    "Build the SPIRV-Reflect test suite" OFF)
 OPTION(SPIRV_REFLECT_ENABLE_ASSERTS "Enable asserts for debugging" OFF)
+OPTION(SPIRV_REFLECT_ENABLE_EVALUATION "Enable evaluating constants' result id" ON)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(CMAKE_CXX_STANDARD 14)
@@ -35,6 +36,9 @@ if (SPIRV_REFLECT_EXECUTABLE)
     if (SPIRV_REFLECT_ENABLE_ASSERTS)
         target_compile_definitions(spirv-reflect PRIVATE SPIRV_REFLECT_ENABLE_ASSERTS)
     endif()
+    if(SPIRV_REFLECT_ENABLE_EVALUATION)
+        target_compile_definitions(spirv-reflect PRIVATE SPIRV_REFLECT_ENABLE_CONSTANT_EVALUATION=1)
+    endif()
     set_target_properties(spirv-reflect PROPERTIES CXX_STANDARD 11)
     target_include_directories(spirv-reflect PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
     if(WIN32)
@@ -63,6 +67,9 @@ if (SPIRV_REFLECT_EXECUTABLE)
     if (SPIRV_REFLECT_ENABLE_ASSERTS)
         target_compile_definitions(spirv-reflect-pp PRIVATE SPIRV_REFLECT_ENABLE_ASSERTS)
     endif()
+    if(SPIRV_REFLECT_ENABLE_EVALUATION)
+        target_compile_definitions(spirv-reflect-pp PRIVATE SPIRV_REFLECT_ENABLE_CONSTANT_EVALUATION=1)
+    endif()
     set_target_properties(spirv-reflect-pp PROPERTIES CXX_STANDARD 11)
     target_include_directories(spirv-reflect-pp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
     if(WIN32)
@@ -98,6 +105,9 @@ if (SPIRV_REFLECT_BUILD_TESTS)
                           CXX_STANDARD 11)
     target_compile_definitions(test-spirv-reflect PRIVATE
                                $<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_WARNINGS>)
+    if(SPIRV_REFLECT_ENABLE_EVALUATION)
+        target_compile_definitions(test-spirv-reflect PRIVATE SPIRV_REFLECT_ENABLE_CONSTANT_EVALUATION=1)
+    endif()
     target_link_libraries(test-spirv-reflect gtest_main)
     target_include_directories(test-spirv-reflect PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
     add_custom_command(TARGET test-spirv-reflect POST_BUILD
@@ -108,7 +118,9 @@ endif()
 if(SPIRV_REFLECT_STATIC_LIB)
     add_library(spirv-reflect-static STATIC ${CMAKE_CURRENT_SOURCE_DIR}/spirv_reflect.h
                                      ${CMAKE_CURRENT_SOURCE_DIR}/spirv_reflect.c)
-
+    if(SPIRV_REFLECT_ENABLE_EVALUATION)
+        target_compile_definitions(spirv-reflect-static PRIVATE SPIRV_REFLECT_ENABLE_CONSTANT_EVALUATION=1)
+    endif()
     target_include_directories(spirv-reflect-static
                                PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
     install(TARGETS spirv-reflect-static LIBRARY DESTINATION lib)

README.md

@@ -19,6 +19,7 @@ SPIRV-Reflect has been tested on Linux and Windows.
 - Remap descriptor bindings at runtime, and update the source SPIR-V bytecode
   accordingly.
 - Log all reflection data as human-readable text.
+- Experimental specialization constant parsing and evaluation
 
 ## Integration
 
@@ -103,8 +104,8 @@ We tested the following bazel build command using Linux Bazel 1.2.1.
 bazel build :all
 ```
 
-## License
-
+## License
+
 Copyright 2017-2018 Google Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");

common/output_stream.cpp

@@ -882,6 +882,7 @@ void ParseBlockMembersToTextLines(const char* indent, int indent_depth,
                                   const std::string& parent_name,
                                   uint32_t member_count,
                                   const SpvReflectBlockVariable* p_members,
+                                  SpvReflectEvaluation* evaluator,
                                   std::vector<TextLine>* p_text_lines) {
   const char* t = indent;
   for (uint32_t member_index = 0; member_index < member_count; ++member_index) {
@@ -927,7 +928,7 @@ void ParseBlockMembersToTextLines(const char* indent, int indent_depth,
           flatten_cbuffers ? p_text_lines : &tl.lines;
       ParseBlockMembersToTextLines(t, indent_depth + 1, flatten_cbuffers,
                                    current_parent_name, member.member_count,
-                                   member.members, p_target_text_line);
+                                   member.members, evaluator, p_target_text_line);
       tl.text_line_flags = TEXT_LINE_TYPE_LINES;
       p_text_lines->push_back(tl);
 
@@ -993,7 +994,14 @@ void ParseBlockMembersToTextLines(const char* indent, int indent_depth,
         for (uint32_t array_dim_index = 0;
              array_dim_index < member.array.dims_count; ++array_dim_index) {
           uint32_t dim = member.array.dims[array_dim_index];
-          ss_array << "[" << dim << "]";
+          if (dim == 0xFFFFFFFF) {
+            const SpvReflectValue* val;
+            SpvReflectResult res = spvReflectEvaluateResult(evaluator, member.array.spec_constant_op_ids[array_dim_index], &val);
+            if ((res == SPV_REFLECT_RESULT_SUCCESS) && val->type && (val->type->type_flags == SPV_REFLECT_TYPE_FLAG_INT) && (val->type->traits.numeric.scalar.width == 32)) {
+              dim = val->data.numeric.scalar.value.uint32_bool_value;
+            }
+          }
+          ss_array << "[" << dim << "]"; 
         }
         tl.name += ss_array.str();
       }
@@ -1010,6 +1018,7 @@ void ParseBlockMembersToTextLines(const char* indent, int indent_depth,
 
 void ParseBlockVariableToTextLines(const char* indent, bool flatten_cbuffers,
                                    const SpvReflectBlockVariable& block_var,
+                                   SpvReflectEvaluation* evaluator,
                                    std::vector<TextLine>* p_text_lines) {
   // Begin block
   TextLine tl = {};
@@ -1026,7 +1035,7 @@ void ParseBlockVariableToTextLines(const char* indent, bool flatten_cbuffers,
   tl = {};
   ParseBlockMembersToTextLines(indent, 2, flatten_cbuffers, "",
                                block_var.member_count, block_var.members,
-                               &tl.lines);
+                               evaluator, &tl.lines);
   tl.text_line_flags = TEXT_LINE_TYPE_LINES;
   p_text_lines->push_back(tl);
 
@@ -1241,6 +1250,7 @@ void StreamWriteTextLines(std::ostream& os, const char* indent,
 
 void StreamWritePushConstantsBlock(std::ostream& os,
                                    const SpvReflectBlockVariable& obj,
+                                   SpvReflectEvaluation* evaluator,
                                    bool flatten_cbuffers, const char* indent) {
   const char* t = indent;
   os << t << "spirv id : " << obj.spirv_id << "\n";
@@ -1253,7 +1263,8 @@ void StreamWritePushConstantsBlock(std::ostream& os,
   }
 
   std::vector<TextLine> text_lines;
-  ParseBlockVariableToTextLines("    ", flatten_cbuffers, obj, &text_lines);
+  ParseBlockVariableToTextLines("    ", flatten_cbuffers, obj, evaluator,
+                                &text_lines);
   if (!text_lines.empty()) {
     os << "\n";
     StreamWriteTextLines(os, t, flatten_cbuffers, text_lines);
@@ -1263,6 +1274,7 @@ void StreamWritePushConstantsBlock(std::ostream& os,
 
 void StreamWriteDescriptorBinding(std::ostream& os,
                                   const SpvReflectDescriptorBinding& obj,
+                                  SpvReflectEvaluation* evaluator,
                                   bool write_set, bool flatten_cbuffers,
                                   const char* indent) {
   const char* t = indent;
@@ -1314,7 +1326,7 @@ void StreamWriteDescriptorBinding(std::ostream& os,
       obj.descriptor_type == SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
     std::vector<TextLine> text_lines;
     ParseBlockVariableToTextLines("    ", flatten_cbuffers, obj.block,
-                                  &text_lines);
+                                  evaluator, &text_lines);
     if (!text_lines.empty()) {
       os << "\n";
       StreamWriteTextLines(os, t, flatten_cbuffers, text_lines);
@@ -1367,6 +1379,68 @@ void StreamWriteInterfaceVariable(std::ostream& os,
   }
 }
 
+void StreamWriteSpecializationConstant(
+    std::ostream& os, const SpvReflectSpecializationConstant& obj,
+    const char* indent) {
+  const char* t = indent;
+  os << t << "spirv id   : " << obj.spirv_id << "\n";
+  os << t << "constant id: " << obj.constant_id << "\n";
+  os << t << "name       : " << (obj.name != NULL ? obj.name : "") << '\n';
+  os << t << "type       : ";
+  int type = 0;
+  if (!obj.type || obj.type->type_flags == SPV_REFLECT_TYPE_FLAG_BOOL) {
+    type = 1;
+  } else if (obj.type->type_flags == SPV_REFLECT_TYPE_FLAG_INT) {
+    type = 2;
+  } else if (obj.type->type_flags == SPV_REFLECT_TYPE_FLAG_FLOAT) {
+    type = 3;
+  }
+  switch (type) {
+    case 1:
+      os << "boolean\n";
+      os << t << "default    : " << obj.default_value.value.uint32_bool_value;
+      break;
+    case 2:
+      if (obj.type->traits.numeric.scalar.signedness) {
+        os << "signed ";
+      } else {
+        os << "unsigned ";
+      }
+      os << obj.type->traits.numeric.scalar.width << " bit integer\n";
+      os << t << "default    : ";
+      // let's assume only 32 bit and 64 bit types (no 8 and 16 bit types here)
+      if (obj.type->traits.numeric.scalar.width == 32) {
+        if (obj.type->traits.numeric.scalar.signedness) {
+          os << obj.default_value.value.sint32_value;
+        } else {
+          os << obj.default_value.value.uint32_bool_value;
+        }
+      } else if (obj.type->traits.numeric.scalar.width == 64) {
+        if (obj.type->traits.numeric.scalar.signedness) {
+          os << obj.default_value.value.sint64_value;
+        } else {
+          os << obj.default_value.value.uint64_value;
+        }
+      } else {
+        os << "default value not native in c/cpp";
+      }
+      break;
+    case 3:
+      os << obj.type->traits.numeric.scalar.width << " bit floating point\n";
+      os << t << "default    : ";
+      if (obj.type->traits.numeric.scalar.width == 32) {
+        os << obj.default_value.value.float32_value;
+      } else if (obj.type->traits.numeric.scalar.width == 64) {
+        os << obj.default_value.value.float64_value;
+      } else {
+        os << "default value not native in c/cpp";
+      }
+      break;
+    default:
+      os << "unknown type";
+  }
+}
+
 void StreamWriteEntryPoint(std::ostream& os, const SpvReflectEntryPoint& obj,
                            const char* indent) {
   os << indent << "entry point     : " << obj.name;
@@ -1420,9 +1494,32 @@ void WriteReflection(const spv_reflect::ShaderModule& obj,
   std::vector<SpvReflectDescriptorBinding*> bindings;
   std::vector<SpvReflectDescriptorSet*> sets;
   std::vector<SpvReflectBlockVariable*> push_constant_bocks;
+  std::vector<SpvReflectSpecializationConstant*> specialization_constants;
+
+  count = 0;
+  SpvReflectResult result = obj.EnumerateSpecializationConstants(&count, nullptr);
+  USE_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
+  specialization_constants.resize(count);
+  result = obj.EnumerateSpecializationConstants(&count, specialization_constants.data());
+  USE_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
+  if (count > 0) {
+    os << "\n";
+    os << "\n";
+    os << "\n";
+    os << t << "Sepecialization constants: " << count << "\n\n";
+    for (size_t i = 0; i < specialization_constants.size(); ++i) {
+      auto p_var = specialization_constants[i];
+      USE_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
+      os << tt << i << ":" << "\n";
+      StreamWriteSpecializationConstant(os, *p_var, ttt);
+      if (i < (count - 1)) {
+        os << "\n";
+      }  
+    }
+  }
 
   count = 0;
-  SpvReflectResult result = obj.EnumerateInputVariables(&count, nullptr);
+  result = obj.EnumerateInputVariables(&count, nullptr);
   USE_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
   variables.resize(count);
   result = obj.EnumerateInputVariables(&count, variables.data());
@@ -1482,7 +1579,8 @@ void WriteReflection(const spv_reflect::ShaderModule& obj,
       auto p_block = push_constant_bocks[i];
       os << tt << i << ":"
          << "\n";
-      StreamWritePushConstantsBlock(os, *p_block, flatten_cbuffers, ttt);
+      StreamWritePushConstantsBlock(os, *p_block, obj.GetEvaluationInterface(),
+                                    flatten_cbuffers, ttt);
     }
   }
 
@@ -1511,7 +1609,8 @@ void WriteReflection(const spv_reflect::ShaderModule& obj,
       os << tt << "Binding"
          << " " << p_binding->set << "." << p_binding->binding << ""
          << "\n";
-      StreamWriteDescriptorBinding(os, *p_binding, true, flatten_cbuffers, ttt);
+      StreamWriteDescriptorBinding(os, *p_binding, obj.GetEvaluationInterface(),
+                                   true, flatten_cbuffers, ttt);
       if (i < (count - 1)) {
         os << "\n\n";
       }

main.cpp

@@ -130,7 +130,7 @@ int main(int argn, char** argv) {
     std::vector<char> spv_data(size);
     spv_ifstream.read(spv_data.data(), size);
 
-    spv_reflect::ShaderModule reflection(spv_data.size(), spv_data.data());
+    spv_reflect::ShaderModule reflection(spv_data.size(), spv_data.data(), SPV_REFLECT_MODULE_FLAG_EVALUATE_CONSTANT);
     if (reflection.GetResult() != SPV_REFLECT_RESULT_SUCCESS) {
       std::cerr << "ERROR: could not process '" << input_spv_path
                 << "' (is it a valid SPIR-V bytecode?)" << std::endl;