From 936876234c7db4922f750f2f7c6ebc1bfebcafa0 Mon Sep 17 00:00:00 2001 From: baldurk Date: Thu, 11 Jul 2019 11:07:28 +0100 Subject: [PATCH] Move SPIR-V utility/parsing/editing code into rdcspv namespace * Everything except the reflection code which will be replaced --- renderdoc/driver/gl/gl_debug.cpp | 6 +- renderdoc/driver/gl/gl_driver.cpp | 4 +- renderdoc/driver/gl/wrappers/gl_emulated.cpp | 14 +- .../driver/gl/wrappers/gl_shader_funcs.cpp | 8 +- .../driver/shaders/spirv/glslang_compile.cpp | 6 +- .../driver/shaders/spirv/glslang_compile.h | 2 +- .../driver/shaders/spirv/spirv_compile.cpp | 20 +- .../driver/shaders/spirv/spirv_compile.h | 26 +- .../driver/shaders/spirv/spirv_editor.cpp | 547 +++++++++--------- renderdoc/driver/shaders/spirv/spirv_editor.h | 375 ++++++------ .../driver/shaders/spirv/spirv_reflect.cpp | 24 +- .../driver/vulkan/vk_bindless_feedback.cpp | 44 +- renderdoc/driver/vulkan/vk_core.cpp | 4 +- renderdoc/driver/vulkan/vk_debug.cpp | 6 +- renderdoc/driver/vulkan/vk_debug.h | 2 - renderdoc/driver/vulkan/vk_postvs.cpp | 118 ++-- renderdoc/driver/vulkan/vk_replay.cpp | 18 +- renderdoc/driver/vulkan/vk_shader_cache.cpp | 48 +- renderdoc/driver/vulkan/vk_shader_cache.h | 2 +- 19 files changed, 636 insertions(+), 638 deletions(-) diff --git a/renderdoc/driver/gl/gl_debug.cpp b/renderdoc/driver/gl/gl_debug.cpp index aeb62c7f3..a0fe803eb 100644 --- a/renderdoc/driver/gl/gl_debug.cpp +++ b/renderdoc/driver/gl/gl_debug.cpp @@ -69,11 +69,11 @@ GLuint GLReplay::CreateSPIRVShader(GLenum shaderType, const std::string &src) return 0; } - SPIRVCompilationSettings settings(SPIRVSourceLanguage::OpenGLGLSL, - SPIRVShaderStage(ShaderIdx(shaderType))); + rdcspv::CompilationSettings settings(rdcspv::InputLanguage::OpenGLGLSL, + rdcspv::ShaderStage(ShaderIdx(shaderType))); std::vector spirv; - std::string s = CompileSPIRV(settings, {src}, spirv); + std::string s = rdcspv::Compile(settings, {src}, spirv); if(spirv.empty()) { diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 19d3ad451..8faff55fc 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -699,8 +699,8 @@ WrappedOpenGL::WrappedOpenGL(GLPlatform &platform) ResourceIDGen::SetReplayResourceIDs(); } - InitSPIRVCompiler(); - RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler); + rdcspv::Init(); + RenderDoc::Inst().RegisterShutdownFunction(&rdcspv::Shutdown); m_CurrentDefaultFBO = 0; diff --git a/renderdoc/driver/gl/wrappers/gl_emulated.cpp b/renderdoc/driver/gl/wrappers/gl_emulated.cpp index 37f82ce36..11a7853f9 100644 --- a/renderdoc/driver/gl/wrappers/gl_emulated.cpp +++ b/renderdoc/driver/gl/wrappers/gl_emulated.cpp @@ -3434,8 +3434,8 @@ void MakeOfflineShaderReflection(ShaderStage stage, const std::string &source, const std::string &entryPoint, ShaderReflection &refl, ShaderBindpointMapping &mapping) { - InitSPIRVCompiler(); - RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler); + rdcspv::Init(); + RenderDoc::Inst().RegisterShutdownFunction(&rdcspv::Shutdown); RDCASSERT(entryPoint == "main"); @@ -3451,7 +3451,7 @@ void MakeOfflineShaderReflection(ShaderStage stage, const std::string &source, GL = GLDispatchTable(); GL.EmulateRequiredExtensions(); - glslang::TShader *sh = CompileShaderForReflection(SPIRVShaderStage(stage), {source}); + glslang::TShader *sh = CompileShaderForReflection(rdcspv::ShaderStage(stage), {source}); REQUIRE(sh); @@ -3575,8 +3575,8 @@ void main() { )"; - InitSPIRVCompiler(); - RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler); + rdcspv::Init(); + RenderDoc::Inst().RegisterShutdownFunction(&rdcspv::Shutdown); // as a hack, create a local 'driver' and just populate m_Programs with what we want. GLDummyPlatform dummy; @@ -3589,8 +3589,8 @@ void main() { GL.EmulateRequiredExtensions(); glslang::TProgram *prog = LinkProgramForReflection( - {CompileShaderForReflection(SPIRVShaderStage::Vertex, {vssource}), - CompileShaderForReflection(SPIRVShaderStage::Fragment, {fssource})}); + {CompileShaderForReflection(rdcspv::ShaderStage::Vertex, {vssource}), + CompileShaderForReflection(rdcspv::ShaderStage::Fragment, {fssource})}); REQUIRE(prog); diff --git a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp index 7445590f4..d571d6b9d 100644 --- a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp @@ -196,7 +196,7 @@ void WrappedOpenGL::ShaderData::ProcessCompilation(WrappedOpenGL &drv, ResourceI // if we don't have program_interface_query, need to compile the shader with glslang to be able // to reflect with. This is needed on capture or replay if(!HasExt[ARB_program_interface_query] && status == 1) - glslangShader = CompileShaderForReflection(SPIRVShaderStage(ShaderIdx(type)), sources); + glslangShader = CompileShaderForReflection(rdcspv::ShaderStage(ShaderIdx(type)), sources); if(IsReplayMode(drv.GetState()) && !drv.IsInternalShader()) { @@ -262,10 +262,10 @@ void WrappedOpenGL::ShaderData::ProcessCompilation(WrappedOpenGL &drv, ResourceI { std::vector spirvwords; - SPIRVCompilationSettings settings(SPIRVSourceLanguage::OpenGLGLSL, - SPIRVShaderStage(ShaderIdx(type))); + rdcspv::CompilationSettings settings(rdcspv::InputLanguage::OpenGLGLSL, + rdcspv::ShaderStage(ShaderIdx(type))); - std::string s = CompileSPIRV(settings, sources, spirvwords); + std::string s = rdcspv::Compile(settings, sources, spirvwords); if(!spirvwords.empty()) ParseSPIRV(&spirvwords.front(), spirvwords.size(), spirv); else diff --git a/renderdoc/driver/shaders/spirv/glslang_compile.cpp b/renderdoc/driver/shaders/spirv/glslang_compile.cpp index 5cdd58846..8369408ed 100644 --- a/renderdoc/driver/shaders/spirv/glslang_compile.cpp +++ b/renderdoc/driver/shaders/spirv/glslang_compile.cpp @@ -148,7 +148,7 @@ TBuiltInResource *GetDefaultResources() return &DefaultResources; } -void InitSPIRVCompiler() +void rdcspv::Init() { if(!glslang_inited) { @@ -160,7 +160,7 @@ void InitSPIRVCompiler() } } -void ShutdownSPIRVCompiler() +void rdcspv::Shutdown() { if(glslang_inited) { @@ -181,7 +181,7 @@ void ShutdownSPIRVCompiler() } } -glslang::TShader *CompileShaderForReflection(SPIRVShaderStage stage, +glslang::TShader *CompileShaderForReflection(rdcspv::ShaderStage stage, const std::vector &sources) { EShLanguage lang = EShLanguage(stage); diff --git a/renderdoc/driver/shaders/spirv/glslang_compile.h b/renderdoc/driver/shaders/spirv/glslang_compile.h index 99261ecc0..aab98f275 100644 --- a/renderdoc/driver/shaders/spirv/glslang_compile.h +++ b/renderdoc/driver/shaders/spirv/glslang_compile.h @@ -34,7 +34,7 @@ class TShader; class TProgram; }; -glslang::TShader *CompileShaderForReflection(SPIRVShaderStage stage, +glslang::TShader *CompileShaderForReflection(rdcspv::ShaderStage stage, const std::vector &sources); glslang::TProgram *LinkProgramForReflection(const std::vector &shaders); diff --git a/renderdoc/driver/shaders/spirv/spirv_compile.cpp b/renderdoc/driver/shaders/spirv/spirv_compile.cpp index 566fd331e..06fd5cb57 100644 --- a/renderdoc/driver/shaders/spirv/spirv_compile.cpp +++ b/renderdoc/driver/shaders/spirv/spirv_compile.cpp @@ -32,10 +32,10 @@ #include "3rdparty/glslang/SPIRV/GlslangToSpv.h" #include "3rdparty/glslang/glslang/Public/ShaderLang.h" -std::string CompileSPIRV(const SPIRVCompilationSettings &settings, - const std::vector &sources, std::vector &spirv) +std::string rdcspv::Compile(const rdcspv::CompilationSettings &settings, + const std::vector &sources, std::vector &spirv) { - if(settings.stage == SPIRVShaderStage::Invalid) + if(settings.stage == rdcspv::ShaderStage::Invalid) return "Invalid shader stage specified"; std::string errors = ""; @@ -45,11 +45,11 @@ std::string CompileSPIRV(const SPIRVCompilationSettings &settings, for(size_t i = 0; i < sources.size(); i++) strs[i] = sources[i].c_str(); - RDCCOMPILE_ASSERT((int)EShLangVertex == (int)SPIRVShaderStage::Vertex && - (int)EShLangTessControl == (int)SPIRVShaderStage::TessControl && - (int)EShLangTessEvaluation == (int)SPIRVShaderStage::TessEvaluation && - (int)EShLangGeometry == (int)SPIRVShaderStage::Geometry && - (int)EShLangCompute == (int)SPIRVShaderStage::Compute, + RDCCOMPILE_ASSERT((int)EShLangVertex == (int)rdcspv::ShaderStage::Vertex && + (int)EShLangTessControl == (int)rdcspv::ShaderStage::TessControl && + (int)EShLangTessEvaluation == (int)rdcspv::ShaderStage::TessEvaluation && + (int)EShLangGeometry == (int)rdcspv::ShaderStage::Geometry && + (int)EShLangCompute == (int)rdcspv::ShaderStage::Compute, "Shader language enums don't match"); { @@ -65,9 +65,9 @@ std::string CompileSPIRV(const SPIRVCompilationSettings &settings, EShMessages flags = EShMsgSpvRules; - if(settings.lang == SPIRVSourceLanguage::VulkanGLSL) + if(settings.lang == rdcspv::InputLanguage::VulkanGLSL) flags = EShMessages(flags | EShMsgVulkanRules); - if(settings.lang == SPIRVSourceLanguage::VulkanHLSL) + if(settings.lang == rdcspv::InputLanguage::VulkanHLSL) flags = EShMessages(flags | EShMsgVulkanRules | EShMsgReadHlsl); bool success = shader->parse(GetDefaultResources(), 110, false, flags); diff --git a/renderdoc/driver/shaders/spirv/spirv_compile.h b/renderdoc/driver/shaders/spirv/spirv_compile.h index 85b292d09..e0f91452e 100644 --- a/renderdoc/driver/shaders/spirv/spirv_compile.h +++ b/renderdoc/driver/shaders/spirv/spirv_compile.h @@ -27,7 +27,9 @@ #include #include -enum class SPIRVShaderStage +namespace rdcspv +{ +enum class ShaderStage { Vertex, TessControl, @@ -38,7 +40,7 @@ enum class SPIRVShaderStage Invalid, }; -enum class SPIRVSourceLanguage +enum class InputLanguage { Unknown, OpenGLGLSL, @@ -46,18 +48,20 @@ enum class SPIRVSourceLanguage VulkanHLSL, }; -struct SPIRVCompilationSettings +struct CompilationSettings { - SPIRVCompilationSettings(SPIRVSourceLanguage l, SPIRVShaderStage s) : stage(s), lang(l) {} - SPIRVCompilationSettings() = default; + CompilationSettings(InputLanguage l, ShaderStage s) : stage(s), lang(l) {} + CompilationSettings() = default; - SPIRVShaderStage stage = SPIRVShaderStage::Invalid; - SPIRVSourceLanguage lang = SPIRVSourceLanguage::Unknown; + ShaderStage stage = ShaderStage::Invalid; + InputLanguage lang = InputLanguage::Unknown; std::string entryPoint; }; -void InitSPIRVCompiler(); -void ShutdownSPIRVCompiler(); +void Init(); +void Shutdown(); -std::string CompileSPIRV(const SPIRVCompilationSettings &settings, - const std::vector &sources, std::vector &spirv); \ No newline at end of file +std::string Compile(const CompilationSettings &settings, const std::vector &sources, + std::vector &spirv); + +}; // namespace rdcspv \ No newline at end of file diff --git a/renderdoc/driver/shaders/spirv/spirv_editor.cpp b/renderdoc/driver/shaders/spirv/spirv_editor.cpp index 9e2cfa695..16b6d4e75 100644 --- a/renderdoc/driver/shaders/spirv/spirv_editor.cpp +++ b/renderdoc/driver/shaders/spirv/spirv_editor.cpp @@ -29,19 +29,21 @@ #include "serialise/serialiser.h" #include "spirv_op_helpers.h" -SPIRVScalar::SPIRVScalar(rdcspv::Iter it) +namespace rdcspv +{ +Scalar::Scalar(Iter it) { type = it.opcode(); - if(type == rdcspv::Op::TypeInt) + if(type == Op::TypeInt) { - rdcspv::OpTypeInt decoded(it); + OpTypeInt decoded(it); width = decoded.width; signedness = decoded.signedness == 1; } - else if(type == rdcspv::Op::TypeFloat) + else if(type == Op::TypeFloat) { - rdcspv::OpTypeFloat decoded(it); + OpTypeFloat decoded(it); width = decoded.width; signedness = false; } @@ -52,45 +54,44 @@ SPIRVScalar::SPIRVScalar(rdcspv::Iter it) } } -rdcspv::Operation SPIRVVector::decl(SPIRVEditor &editor) const +Operation Vector::decl(Editor &editor) const { - return rdcspv::OpTypeVector(rdcspv::Id(), editor.DeclareType(scalar), count); + return OpTypeVector(Id(), editor.DeclareType(scalar), count); } -rdcspv::Operation SPIRVMatrix::decl(SPIRVEditor &editor) const +Operation Matrix::decl(Editor &editor) const { - return rdcspv::OpTypeMatrix(rdcspv::Id(), editor.DeclareType(vector), count); + return OpTypeMatrix(Id(), editor.DeclareType(vector), count); } -rdcspv::Operation SPIRVPointer::decl(SPIRVEditor &editor) const +Operation Pointer::decl(Editor &editor) const { - return rdcspv::OpTypePointer(rdcspv::Id(), storage, baseId); + return OpTypePointer(Id(), storage, baseId); } -rdcspv::Operation SPIRVImage::decl(SPIRVEditor &editor) const +Operation Image::decl(Editor &editor) const { - return rdcspv::OpTypeImage(rdcspv::Id(), editor.DeclareType(retType), dim, depth, arrayed, ms, - sampled, format); + return OpTypeImage(Id(), editor.DeclareType(retType), dim, depth, arrayed, ms, sampled, format); } -rdcspv::Operation SPIRVSampler::decl(SPIRVEditor &editor) const +Operation Sampler::decl(Editor &editor) const { - return rdcspv::OpTypeSampler(rdcspv::Id()); + return OpTypeSampler(Id()); } -rdcspv::Operation SPIRVSampledImage::decl(SPIRVEditor &editor) const +Operation SampledImage::decl(Editor &editor) const { - return rdcspv::OpTypeSampledImage(rdcspv::Id(), baseId); + return OpTypeSampledImage(Id(), baseId); } -rdcspv::Operation SPIRVFunction::decl(SPIRVEditor &editor) const +Operation Function::decl(Editor &editor) const { - return rdcspv::OpTypeFunction(rdcspv::Id(), returnId, argumentIds); + return OpTypeFunction(Id(), returnId, argumentIds); } -SPIRVEditor::SPIRVEditor(std::vector &spirvWords) : spirv(spirvWords) +Editor::Editor(std::vector &spirvWords) : spirv(spirvWords) { - if(spirv.size() < rdcspv::FirstRealWord || spirv[0] != rdcspv::MagicNumber) + if(spirv.size() < FirstRealWord || spirv[0] != MagicNumber) { RDCERR("Empty or invalid SPIR-V module"); return; @@ -122,66 +123,64 @@ SPIRVEditor::SPIRVEditor(std::vector &spirvWords) : spirv(spirvWords) // Functions: REQUIRED (must have the entry point) // set the book-ends: start of the first section and end of the last - sections[SPIRVSection::Count - 1].endOffset = spirvWords.size(); + sections[Section::Count - 1].endOffset = spirvWords.size(); #define START_SECTION(section) \ if(sections[section].startOffset == 0) \ sections[section].startOffset = it.offs(); - for(rdcspv::Iter it(spirv, rdcspv::FirstRealWord); it; it++) + for(Iter it(spirv, FirstRealWord); it; it++) { - rdcspv::Op opcode = it.opcode(); + Op opcode = it.opcode(); - if(opcode == rdcspv::Op::Capability) + if(opcode == Op::Capability) { - START_SECTION(SPIRVSection::Capabilities); + START_SECTION(Section::Capabilities); } - else if(opcode == rdcspv::Op::Extension) + else if(opcode == Op::Extension) { - START_SECTION(SPIRVSection::Extensions); + START_SECTION(Section::Extensions); } - else if(opcode == rdcspv::Op::ExtInstImport) + else if(opcode == Op::ExtInstImport) { - START_SECTION(SPIRVSection::ExtInst); + START_SECTION(Section::ExtInst); } - else if(opcode == rdcspv::Op::MemoryModel) + else if(opcode == Op::MemoryModel) { - START_SECTION(SPIRVSection::MemoryModel); + START_SECTION(Section::MemoryModel); } - else if(opcode == rdcspv::Op::EntryPoint) + else if(opcode == Op::EntryPoint) { - START_SECTION(SPIRVSection::EntryPoints); + START_SECTION(Section::EntryPoints); } - else if(opcode == rdcspv::Op::ExecutionMode || opcode == rdcspv::Op::ExecutionModeId) + else if(opcode == Op::ExecutionMode || opcode == Op::ExecutionModeId) { - START_SECTION(SPIRVSection::ExecutionMode); + START_SECTION(Section::ExecutionMode); } - else if(opcode == rdcspv::Op::String || opcode == rdcspv::Op::Source || - opcode == rdcspv::Op::SourceContinued || opcode == rdcspv::Op::SourceExtension || - opcode == rdcspv::Op::Name || opcode == rdcspv::Op::MemberName || - opcode == rdcspv::Op::ModuleProcessed) + else if(opcode == Op::String || opcode == Op::Source || opcode == Op::SourceContinued || + opcode == Op::SourceExtension || opcode == Op::Name || opcode == Op::MemberName || + opcode == Op::ModuleProcessed) { - START_SECTION(SPIRVSection::Debug); + START_SECTION(Section::Debug); } - else if(opcode == rdcspv::Op::Decorate || opcode == rdcspv::Op::MemberDecorate || - opcode == rdcspv::Op::GroupDecorate || opcode == rdcspv::Op::GroupMemberDecorate || - opcode == rdcspv::Op::DecorationGroup || opcode == rdcspv::Op::DecorateStringGOOGLE || - opcode == rdcspv::Op::MemberDecorateStringGOOGLE) + else if(opcode == Op::Decorate || opcode == Op::MemberDecorate || opcode == Op::GroupDecorate || + opcode == Op::GroupMemberDecorate || opcode == Op::DecorationGroup || + opcode == Op::DecorateStringGOOGLE || opcode == Op::MemberDecorateStringGOOGLE) { - START_SECTION(SPIRVSection::Annotations); + START_SECTION(Section::Annotations); } - else if(opcode == rdcspv::Op::Function) + else if(opcode == Op::Function) { - START_SECTION(SPIRVSection::Functions); + START_SECTION(Section::Functions); } else { // if we've reached another instruction, check if we've reached the function section yet. If // we have then assume it's an instruction inside a function and ignore. If we haven't, assume // it's a type/variable/constant type instruction - if(sections[SPIRVSection::Functions].startOffset == 0) + if(sections[Section::Functions].startOffset == 0) { - START_SECTION(SPIRVSection::TypesVariablesConstants); + START_SECTION(Section::TypesVariablesConstants); } } @@ -191,11 +190,11 @@ SPIRVEditor::SPIRVEditor(std::vector &spirvWords) : spirv(spirvWords) #undef START_SECTION // ensure we got everything right. First section should start at the beginning - RDCASSERTEQUAL(sections[SPIRVSection::First].startOffset, rdcspv::FirstRealWord); + RDCASSERTEQUAL(sections[Section::First].startOffset, FirstRealWord); // we now set the endOffset of each section to the start of the next. Any empty sections // temporarily have startOffset set to endOffset, we'll pad them with a nop below. - for(int s = SPIRVSection::Count - 1; s > 0; s--) + for(int s = Section::Count - 1; s > 0; s--) { RDCASSERTEQUAL(sections[s - 1].endOffset, 0); sections[s - 1].endOffset = sections[s].startOffset; @@ -207,14 +206,14 @@ SPIRVEditor::SPIRVEditor(std::vector &spirvWords) : spirv(spirvWords) // offsets by hand as addWords doesn't handle empty sections properly (it thinks we're inserting // into the later section by offset since the offsets overlap). That's why we're adding these // padding nops in the first place! - for(uint32_t s = 0; s < SPIRVSection::Count; s++) + for(uint32_t s = 0; s < Section::Count; s++) { if(sections[s].startOffset == sections[s].endOffset) { - spirv.insert(spirv.begin() + sections[s].startOffset, rdcspv::OpNopWord); + spirv.insert(spirv.begin() + sections[s].startOffset, OpNopWord); sections[s].endOffset++; - for(uint32_t t = s + 1; t < SPIRVSection::Count; t++) + for(uint32_t t = s + 1; t < Section::Count; t++) { sections[t].startOffset++; sections[t].endOffset++; @@ -228,7 +227,7 @@ SPIRVEditor::SPIRVEditor(std::vector &spirvWords) : spirv(spirvWords) } // each section should now precisely match each other end-to-end and not be empty - for(uint32_t s = SPIRVSection::First; s < SPIRVSection::Count; s++) + for(uint32_t s = Section::First; s < Section::Count; s++) { RDCASSERTNOTEQUAL(sections[s].startOffset, 0); RDCASSERTNOTEQUAL(sections[s].endOffset, 0); @@ -239,22 +238,22 @@ SPIRVEditor::SPIRVEditor(std::vector &spirvWords) : spirv(spirvWords) if(s != 0) RDCASSERTEQUAL(sections[s - 1].endOffset, sections[s].startOffset); - if(s + 1 < SPIRVSection::Count) + if(s + 1 < Section::Count) RDCASSERTEQUAL(sections[s].endOffset, sections[s + 1].startOffset); } } -void SPIRVEditor::StripNops() +void Editor::StripNops() { - for(size_t i = rdcspv::FirstRealWord; i < spirv.size();) + for(size_t i = FirstRealWord; i < spirv.size();) { - while(spirv[i] == rdcspv::OpNopWord) + while(spirv[i] == OpNopWord) { spirv.erase(spirv.begin() + i); addWords(i, -1); } - uint32_t len = spirv[i] >> rdcspv::WordCountShift; + uint32_t len = spirv[i] >> WordCountShift; if(len == 0) { @@ -266,16 +265,16 @@ void SPIRVEditor::StripNops() } } -rdcspv::Id SPIRVEditor::MakeId() +Id Editor::MakeId() { uint32_t ret = spirv[3]; spirv[3]++; idOffsets.resize(spirv[3]); idTypes.resize(spirv[3]); - return rdcspv::Id::fromWord(ret); + return Id::fromWord(ret); } -void SPIRVEditor::SetName(rdcspv::Id id, const char *name) +void Editor::SetName(Id id, const char *name) { size_t sz = strlen(name); std::vector uintName((sz / 4) + 1); @@ -283,54 +282,54 @@ void SPIRVEditor::SetName(rdcspv::Id id, const char *name) uintName.insert(uintName.begin(), id.value()); - rdcspv::Operation op(rdcspv::Op::Name, uintName); + Operation op(Op::Name, uintName); - rdcspv::Iter it; + Iter it; // OpName must be before OpModuleProcessed. - for(it = Begin(SPIRVSection::Debug); it < End(SPIRVSection::Debug); ++it) + for(it = Begin(Section::Debug); it < End(Section::Debug); ++it) { - if(it.opcode() == rdcspv::Op::ModuleProcessed) + if(it.opcode() == Op::ModuleProcessed) break; } op.insertInto(spirv, it.offs()); - RegisterOp(rdcspv::Iter(spirv, it.offs())); + RegisterOp(Iter(spirv, it.offs())); addWords(it.offs(), op.size()); } -void SPIRVEditor::AddDecoration(const rdcspv::Operation &op) +void Editor::AddDecoration(const Operation &op) { - size_t offset = sections[SPIRVSection::Annotations].endOffset; + size_t offset = sections[Section::Annotations].endOffset; op.insertInto(spirv, offset); - RegisterOp(rdcspv::Iter(spirv, offset)); + RegisterOp(Iter(spirv, offset)); addWords(offset, op.size()); } -void SPIRVEditor::AddCapability(rdcspv::Capability cap) +void Editor::AddCapability(Capability cap) { // don't add duplicate capabilities if(capabilities.find(cap) != capabilities.end()) return; // insert the operation at the very start - rdcspv::Operation op(rdcspv::Op::Capability, {(uint32_t)cap}); - op.insertInto(spirv, rdcspv::FirstRealWord); - RegisterOp(rdcspv::Iter(spirv, rdcspv::FirstRealWord)); - addWords(rdcspv::FirstRealWord, op.size()); + Operation op(Op::Capability, {(uint32_t)cap}); + op.insertInto(spirv, FirstRealWord); + RegisterOp(Iter(spirv, FirstRealWord)); + addWords(FirstRealWord, op.size()); } -void SPIRVEditor::AddExtension(const rdcstr &extension) +void Editor::AddExtension(const rdcstr &extension) { // don't add duplicate extensions if(extensions.find(extension) != extensions.end()) return; // start at the beginning - rdcspv::Iter it(spirv, rdcspv::FirstRealWord); + Iter it(spirv, FirstRealWord); // skip past any capabilities - while(it.opcode() == rdcspv::Op::Capability) + while(it.opcode() == Op::Capability) it++; // insert the extension instruction @@ -338,33 +337,33 @@ void SPIRVEditor::AddExtension(const rdcstr &extension) std::vector uintName((sz / 4) + 1); memcpy(&uintName[0], extension.c_str(), sz); - rdcspv::Operation op(rdcspv::Op::Extension, uintName); + Operation op(Op::Extension, uintName); op.insertInto(spirv, it.offs()); RegisterOp(it); addWords(it.offs(), op.size()); } -void SPIRVEditor::AddExecutionMode(const rdcspv::Operation &mode) +void Editor::AddExecutionMode(const Operation &mode) { - size_t offset = sections[SPIRVSection::ExecutionMode].endOffset; + size_t offset = sections[Section::ExecutionMode].endOffset; mode.insertInto(spirv, offset); - RegisterOp(rdcspv::Iter(spirv, offset)); + RegisterOp(Iter(spirv, offset)); addWords(offset, mode.size()); } -rdcspv::Id SPIRVEditor::ImportExtInst(const char *setname) +Id Editor::ImportExtInst(const char *setname) { - rdcspv::Id ret = extSets[setname]; + Id ret = extSets[setname]; if(ret) return ret; // start at the beginning - rdcspv::Iter it(spirv, rdcspv::FirstRealWord); + Iter it(spirv, FirstRealWord); // skip past any capabilities and extensions - while(it.opcode() == rdcspv::Op::Capability || it.opcode() == rdcspv::Op::Extension) + while(it.opcode() == Op::Capability || it.opcode() == Op::Extension) it++; // insert the import instruction @@ -376,7 +375,7 @@ rdcspv::Id SPIRVEditor::ImportExtInst(const char *setname) uintName.insert(uintName.begin(), ret.value()); - rdcspv::Operation op(rdcspv::Op::ExtInstImport, uintName); + Operation op(Op::ExtInstImport, uintName); op.insertInto(spirv, it.offs()); RegisterOp(it); addWords(it.offs(), op.size()); @@ -386,87 +385,87 @@ rdcspv::Id SPIRVEditor::ImportExtInst(const char *setname) return ret; } -rdcspv::Id SPIRVEditor::AddType(const rdcspv::Operation &op) +Id Editor::AddType(const Operation &op) { - size_t offset = sections[SPIRVSection::Types].endOffset; + size_t offset = sections[Section::Types].endOffset; - rdcspv::Id id = rdcspv::Id::fromWord(op[1]); + Id id = Id::fromWord(op[1]); idOffsets[id.value()] = offset; op.insertInto(spirv, offset); - RegisterOp(rdcspv::Iter(spirv, offset)); + RegisterOp(Iter(spirv, offset)); addWords(offset, op.size()); return id; } -rdcspv::Id SPIRVEditor::AddVariable(const rdcspv::Operation &op) +Id Editor::AddVariable(const Operation &op) { - size_t offset = sections[SPIRVSection::Variables].endOffset; + size_t offset = sections[Section::Variables].endOffset; - rdcspv::Id id = rdcspv::Id::fromWord(op[2]); + Id id = Id::fromWord(op[2]); idOffsets[id.value()] = offset; op.insertInto(spirv, offset); - RegisterOp(rdcspv::Iter(spirv, offset)); + RegisterOp(Iter(spirv, offset)); addWords(offset, op.size()); return id; } -rdcspv::Id SPIRVEditor::AddConstant(const rdcspv::Operation &op) +Id Editor::AddConstant(const Operation &op) { - size_t offset = sections[SPIRVSection::Constants].endOffset; + size_t offset = sections[Section::Constants].endOffset; - rdcspv::Id id = rdcspv::Id::fromWord(op[2]); + Id id = Id::fromWord(op[2]); idOffsets[id.value()] = offset; op.insertInto(spirv, offset); - RegisterOp(rdcspv::Iter(spirv, offset)); + RegisterOp(Iter(spirv, offset)); addWords(offset, op.size()); return id; } -void SPIRVEditor::AddFunction(const rdcspv::Operation *ops, size_t count) +void Editor::AddFunction(const Operation *ops, size_t count) { idOffsets[ops[0][2]] = spirv.size(); for(size_t i = 0; i < count; i++) ops[i].appendTo(spirv); - RegisterOp(rdcspv::Iter(spirv, idOffsets[ops[0][2]])); + RegisterOp(Iter(spirv, idOffsets[ops[0][2]])); } -rdcspv::Iter SPIRVEditor::GetID(rdcspv::Id id) +Iter Editor::GetID(Id id) { size_t offs = idOffsets[id.value()]; if(offs) - return rdcspv::Iter(spirv, offs); + return Iter(spirv, offs); - return rdcspv::Iter(); + return Iter(); } -rdcspv::Iter SPIRVEditor::GetEntry(rdcspv::Id id) +Iter Editor::GetEntry(Id id) { - rdcspv::Iter it(spirv, sections[SPIRVSection::EntryPoints].startOffset); - rdcspv::Iter end(spirv, sections[SPIRVSection::EntryPoints].endOffset); + Iter it(spirv, sections[Section::EntryPoints].startOffset); + Iter end(spirv, sections[Section::EntryPoints].endOffset); while(it && it < end) { - rdcspv::OpEntryPoint entry(it); + OpEntryPoint entry(it); if(entry.entryPoint == id.value()) return it; it++; } - return rdcspv::Iter(); + return Iter(); } -rdcspv::Id SPIRVEditor::DeclareStructType(const std::vector &members) +Id Editor::DeclareStructType(const std::vector &members) { - rdcspv::Id typeId = MakeId(); - AddType(rdcspv::OpTypeStruct(typeId, members)); + Id typeId = MakeId(); + AddType(OpTypeStruct(typeId, members)); return typeId; } -void SPIRVEditor::AddOperation(rdcspv::Iter iter, const rdcspv::Operation &op) +void Editor::AddOperation(Iter iter, const Operation &op) { if(!iter) return; @@ -478,78 +477,77 @@ void SPIRVEditor::AddOperation(rdcspv::Iter iter, const rdcspv::Operation &op) addWords(iter.offs(), op.size()); } -void SPIRVEditor::RegisterOp(rdcspv::Iter it) +void Editor::RegisterOp(Iter it) { - rdcspv::Op opcode = it.opcode(); + Op opcode = it.opcode(); - rdcspv::OpDecoder opdata(it); - if(opdata.result != rdcspv::Id() && opdata.resultType != rdcspv::Id()) + OpDecoder opdata(it); + if(opdata.result != Id() && opdata.resultType != Id()) { RDCASSERT(opdata.result.value() < idTypes.size()); idTypes[opdata.result.value()] = opdata.resultType; } - if(opdata.result != rdcspv::Id()) + if(opdata.result != Id()) idOffsets[opdata.result.value()] = it.offs(); - if(opcode == rdcspv::Op::EntryPoint) + if(opcode == Op::EntryPoint) { - entries.push_back(rdcspv::OpEntryPoint(it)); + entries.push_back(OpEntryPoint(it)); } - else if(opcode == rdcspv::Op::MemoryModel) + else if(opcode == Op::MemoryModel) { - rdcspv::OpMemoryModel decoded(it); + OpMemoryModel decoded(it); addressmodel = decoded.addressingModel; memorymodel = decoded.memoryModel; } - else if(opcode == rdcspv::Op::Capability) + else if(opcode == Op::Capability) { - rdcspv::OpCapability decoded(it); + OpCapability decoded(it); capabilities.insert(decoded.capability); } - else if(opcode == rdcspv::Op::Extension) + else if(opcode == Op::Extension) { - rdcspv::OpExtension decoded(it); + OpExtension decoded(it); extensions.insert(decoded.name); } - else if(opcode == rdcspv::Op::ExtInstImport) + else if(opcode == Op::ExtInstImport) { - rdcspv::OpExtInstImport decoded(it); + OpExtInstImport decoded(it); extSets[decoded.name] = decoded.result; } - else if(opcode == rdcspv::Op::Function) + else if(opcode == Op::Function) { functions.push_back(opdata.result); } - else if(opcode == rdcspv::Op::Variable) + else if(opcode == Op::Variable) { - variables.push_back(rdcspv::OpVariable(it)); + variables.push_back(OpVariable(it)); } - else if(opcode == rdcspv::Op::Decorate) + else if(opcode == Op::Decorate) { - rdcspv::OpDecorate decorate(it); + OpDecorate decorate(it); - auto it = std::lower_bound( - decorations.begin(), decorations.end(), decorate, - [](const rdcspv::OpDecorate &a, const rdcspv::OpDecorate &b) { return a < b; }); + auto it = std::lower_bound(decorations.begin(), decorations.end(), decorate, + [](const OpDecorate &a, const OpDecorate &b) { return a < b; }); decorations.insert(it, decorate); - if(decorate.decoration == rdcspv::Decoration::DescriptorSet) + if(decorate.decoration == Decoration::DescriptorSet) bindings[decorate.target].set = decorate.decoration.descriptorSet; - if(decorate.decoration == rdcspv::Decoration::Binding) + if(decorate.decoration == Decoration::Binding) bindings[decorate.target].binding = decorate.decoration.binding; } - else if(opcode == rdcspv::Op::TypeVoid || opcode == rdcspv::Op::TypeBool || - opcode == rdcspv::Op::TypeInt || opcode == rdcspv::Op::TypeFloat) + else if(opcode == Op::TypeVoid || opcode == Op::TypeBool || opcode == Op::TypeInt || + opcode == Op::TypeFloat) { - SPIRVScalar scalar(it); + Scalar scalar(it); scalarTypes[scalar] = opdata.result; } - else if(opcode == rdcspv::Op::TypeVector) + else if(opcode == Op::TypeVector) { - rdcspv::OpTypeVector decoded(it); + OpTypeVector decoded(it); - rdcspv::Iter scalarIt = GetID(decoded.componentType); + Iter scalarIt = GetID(decoded.componentType); if(!scalarIt) { @@ -557,13 +555,13 @@ void SPIRVEditor::RegisterOp(rdcspv::Iter it) return; } - vectorTypes[SPIRVVector(scalarIt, decoded.componentCount)] = decoded.result; + vectorTypes[Vector(scalarIt, decoded.componentCount)] = decoded.result; } - else if(opcode == rdcspv::Op::TypeMatrix) + else if(opcode == Op::TypeMatrix) { - rdcspv::OpTypeMatrix decodedMatrix(it); + OpTypeMatrix decodedMatrix(it); - rdcspv::Iter vectorIt = GetID(decodedMatrix.columnType); + Iter vectorIt = GetID(decodedMatrix.columnType); if(!vectorIt) { @@ -571,18 +569,18 @@ void SPIRVEditor::RegisterOp(rdcspv::Iter it) return; } - rdcspv::OpTypeVector decodedVector(vectorIt); + OpTypeVector decodedVector(vectorIt); - rdcspv::Iter scalarIt = GetID(decodedVector.componentType); + Iter scalarIt = GetID(decodedVector.componentType); - matrixTypes[SPIRVMatrix(SPIRVVector(scalarIt, decodedVector.componentCount), - decodedMatrix.columnCount)] = decodedMatrix.result; + matrixTypes[Matrix(Vector(scalarIt, decodedVector.componentCount), decodedMatrix.columnCount)] = + decodedMatrix.result; } - else if(opcode == rdcspv::Op::TypeImage) + else if(opcode == Op::TypeImage) { - rdcspv::OpTypeImage decoded(it); + OpTypeImage decoded(it); - rdcspv::Iter scalarIt = GetID(decoded.sampledType); + Iter scalarIt = GetID(decoded.sampledType); if(!scalarIt) { @@ -590,51 +588,51 @@ void SPIRVEditor::RegisterOp(rdcspv::Iter it) return; } - imageTypes[SPIRVImage(scalarIt, decoded.dim, decoded.depth, decoded.arrayed, decoded.mS, - decoded.sampled, decoded.imageFormat)] = decoded.result; + imageTypes[Image(scalarIt, decoded.dim, decoded.depth, decoded.arrayed, decoded.mS, + decoded.sampled, decoded.imageFormat)] = decoded.result; } - else if(opcode == rdcspv::Op::TypeSampler) + else if(opcode == Op::TypeSampler) { - samplerTypes[SPIRVSampler()] = opdata.result; + samplerTypes[Sampler()] = opdata.result; } - else if(opcode == rdcspv::Op::TypeSampledImage) + else if(opcode == Op::TypeSampledImage) { - rdcspv::OpTypeSampledImage decoded(it); + OpTypeSampledImage decoded(it); - sampledImageTypes[SPIRVSampledImage(decoded.imageType)] = decoded.result; + sampledImageTypes[SampledImage(decoded.imageType)] = decoded.result; } - else if(opcode == rdcspv::Op::TypePointer) + else if(opcode == Op::TypePointer) { - rdcspv::OpTypePointer decoded(it); + OpTypePointer decoded(it); - pointerTypes[SPIRVPointer(decoded.type, decoded.storageClass)] = decoded.result; + pointerTypes[Pointer(decoded.type, decoded.storageClass)] = decoded.result; } - else if(opcode == rdcspv::Op::TypeStruct) + else if(opcode == Op::TypeStruct) { structTypes.insert(opdata.result); } - else if(opcode == rdcspv::Op::TypeFunction) + else if(opcode == Op::TypeFunction) { - rdcspv::OpTypeFunction decoded(it); + OpTypeFunction decoded(it); - functionTypes[SPIRVFunction(decoded.returnType, decoded.parameters)] = decoded.result; + functionTypes[Function(decoded.returnType, decoded.parameters)] = decoded.result; } } -void SPIRVEditor::UnregisterOp(rdcspv::Iter it) +void Editor::UnregisterOp(Iter it) { - rdcspv::Op opcode = it.opcode(); + Op opcode = it.opcode(); - rdcspv::OpDecoder opdata(it); - if(opdata.result != rdcspv::Id() && opdata.resultType != rdcspv::Id()) - idTypes[opdata.result.value()] = rdcspv::Id(); + OpDecoder opdata(it); + if(opdata.result != Id() && opdata.resultType != Id()) + idTypes[opdata.result.value()] = Id(); - if(opdata.result != rdcspv::Id()) + if(opdata.result != Id()) idOffsets[opdata.result.value()] = 0; - if(opcode == rdcspv::Op::EntryPoint) + if(opcode == Op::EntryPoint) { - rdcspv::OpEntryPoint decoded(it); + OpEntryPoint decoded(it); for(auto entryIt = entries.begin(); entryIt != entries.end(); ++entryIt) { @@ -645,7 +643,7 @@ void SPIRVEditor::UnregisterOp(rdcspv::Iter it) } } } - else if(opcode == rdcspv::Op::Function) + else if(opcode == Op::Function) { for(auto funcIt = functions.begin(); funcIt != functions.end(); ++funcIt) { @@ -656,7 +654,7 @@ void SPIRVEditor::UnregisterOp(rdcspv::Iter it) } } } - else if(opcode == rdcspv::Op::Variable) + else if(opcode == Op::Variable) { for(auto varIt = variables.begin(); varIt != variables.end(); ++varIt) { @@ -667,47 +665,46 @@ void SPIRVEditor::UnregisterOp(rdcspv::Iter it) } } } - else if(opcode == rdcspv::Op::Decorate) + else if(opcode == Op::Decorate) { - rdcspv::OpDecorate decorate(it); + OpDecorate decorate(it); - auto it = std::lower_bound( - decorations.begin(), decorations.end(), decorate, - [](const rdcspv::OpDecorate &a, const rdcspv::OpDecorate &b) { return a < b; }); + auto it = std::lower_bound(decorations.begin(), decorations.end(), decorate, + [](const OpDecorate &a, const OpDecorate &b) { return a < b; }); if(it != decorations.end() && *it == decorate) decorations.erase(it); - if(decorate.decoration == rdcspv::Decoration::DescriptorSet) - bindings[decorate.target].set = SPIRVBinding().set; - if(decorate.decoration == rdcspv::Decoration::Binding) - bindings[decorate.target].binding = SPIRVBinding().binding; + if(decorate.decoration == Decoration::DescriptorSet) + bindings[decorate.target].set = Binding().set; + if(decorate.decoration == Decoration::Binding) + bindings[decorate.target].binding = Binding().binding; } - else if(opcode == rdcspv::Op::Capability) + else if(opcode == Op::Capability) { - rdcspv::OpCapability decoded(it); + OpCapability decoded(it); capabilities.erase(decoded.capability); } - else if(opcode == rdcspv::Op::Extension) + else if(opcode == Op::Extension) { - rdcspv::OpExtension decoded(it); + OpExtension decoded(it); extensions.erase(decoded.name); } - else if(opcode == rdcspv::Op::ExtInstImport) + else if(opcode == Op::ExtInstImport) { - rdcspv::OpExtInstImport decoded(it); + OpExtInstImport decoded(it); extSets.erase(decoded.name); } - else if(opcode == rdcspv::Op::TypeVoid || opcode == rdcspv::Op::TypeBool || - opcode == rdcspv::Op::TypeInt || opcode == rdcspv::Op::TypeFloat) + else if(opcode == Op::TypeVoid || opcode == Op::TypeBool || opcode == Op::TypeInt || + opcode == Op::TypeFloat) { - SPIRVScalar scalar(it); + Scalar scalar(it); scalarTypes.erase(scalar); } - else if(opcode == rdcspv::Op::TypeVector) + else if(opcode == Op::TypeVector) { - rdcspv::OpTypeVector decoded(it); + OpTypeVector decoded(it); - rdcspv::Iter scalarIt = GetID(decoded.componentType); + Iter scalarIt = GetID(decoded.componentType); if(!scalarIt) { @@ -715,13 +712,13 @@ void SPIRVEditor::UnregisterOp(rdcspv::Iter it) return; } - vectorTypes.erase(SPIRVVector(scalarIt, decoded.componentCount)); + vectorTypes.erase(Vector(scalarIt, decoded.componentCount)); } - else if(opcode == rdcspv::Op::TypeMatrix) + else if(opcode == Op::TypeMatrix) { - rdcspv::OpTypeMatrix decodedMatrix(it); + OpTypeMatrix decodedMatrix(it); - rdcspv::Iter vectorIt = GetID(decodedMatrix.columnType); + Iter vectorIt = GetID(decodedMatrix.columnType); if(!vectorIt) { @@ -729,18 +726,18 @@ void SPIRVEditor::UnregisterOp(rdcspv::Iter it) return; } - rdcspv::OpTypeVector decodedVector(vectorIt); + OpTypeVector decodedVector(vectorIt); - rdcspv::Iter scalarIt = GetID(decodedVector.componentType); + Iter scalarIt = GetID(decodedVector.componentType); - matrixTypes.erase(SPIRVMatrix(SPIRVVector(scalarIt, decodedVector.componentCount), - decodedMatrix.columnCount)); + matrixTypes.erase( + Matrix(Vector(scalarIt, decodedVector.componentCount), decodedMatrix.columnCount)); } - else if(opcode == rdcspv::Op::TypeImage) + else if(opcode == Op::TypeImage) { - rdcspv::OpTypeImage decoded(it); + OpTypeImage decoded(it); - rdcspv::Iter scalarIt = GetID(decoded.sampledType); + Iter scalarIt = GetID(decoded.sampledType); if(!scalarIt) { @@ -748,38 +745,38 @@ void SPIRVEditor::UnregisterOp(rdcspv::Iter it) return; } - imageTypes.erase(SPIRVImage(scalarIt, decoded.dim, decoded.depth, decoded.arrayed, decoded.mS, - decoded.sampled, decoded.imageFormat)); + imageTypes.erase(Image(scalarIt, decoded.dim, decoded.depth, decoded.arrayed, decoded.mS, + decoded.sampled, decoded.imageFormat)); } - else if(opcode == rdcspv::Op::TypeSampler) + else if(opcode == Op::TypeSampler) { - samplerTypes.erase(SPIRVSampler()); + samplerTypes.erase(Sampler()); } - else if(opcode == rdcspv::Op::TypeSampledImage) + else if(opcode == Op::TypeSampledImage) { - rdcspv::OpTypeSampledImage decoded(it); + OpTypeSampledImage decoded(it); - sampledImageTypes.erase(SPIRVSampledImage(decoded.imageType)); + sampledImageTypes.erase(SampledImage(decoded.imageType)); } - else if(opcode == rdcspv::Op::TypePointer) + else if(opcode == Op::TypePointer) { - rdcspv::OpTypePointer decoded(it); + OpTypePointer decoded(it); - pointerTypes.erase(SPIRVPointer(decoded.type, decoded.storageClass)); + pointerTypes.erase(Pointer(decoded.type, decoded.storageClass)); } - else if(opcode == rdcspv::Op::TypeStruct) + else if(opcode == Op::TypeStruct) { structTypes.erase(opdata.result); } - else if(opcode == rdcspv::Op::TypeFunction) + else if(opcode == Op::TypeFunction) { - rdcspv::OpTypeFunction decoded(it); + OpTypeFunction decoded(it); - functionTypes.erase(SPIRVFunction(decoded.returnType, decoded.parameters)); + functionTypes.erase(Function(decoded.returnType, decoded.parameters)); } } -void SPIRVEditor::addWords(size_t offs, int32_t num) +void Editor::addWords(size_t offs, int32_t num) { // look through every section, any that are >= this point, adjust the offsets // note that if we're removing words then any offsets pointing directly to the removed words @@ -820,26 +817,28 @@ void SPIRVEditor::addWords(size_t offs, int32_t num) o += num; } -#define TYPETABLE(StructType, variable) \ - template <> \ - std::map &SPIRVEditor::GetTable() \ - { \ - return variable; \ - } \ - template <> \ - const std::map &SPIRVEditor::GetTable() const \ - { \ - return variable; \ +#define TYPETABLE(StructType, variable) \ + template <> \ + std::map &Editor::GetTable() \ + { \ + return variable; \ + } \ + template <> \ + const std::map &Editor::GetTable() const \ + { \ + return variable; \ } -TYPETABLE(SPIRVScalar, scalarTypes); -TYPETABLE(SPIRVVector, vectorTypes); -TYPETABLE(SPIRVMatrix, matrixTypes); -TYPETABLE(SPIRVPointer, pointerTypes); -TYPETABLE(SPIRVImage, imageTypes); -TYPETABLE(SPIRVSampler, samplerTypes); -TYPETABLE(SPIRVSampledImage, sampledImageTypes); -TYPETABLE(SPIRVFunction, functionTypes); +TYPETABLE(Scalar, scalarTypes); +TYPETABLE(Vector, vectorTypes); +TYPETABLE(Matrix, matrixTypes); +TYPETABLE(Pointer, pointerTypes); +TYPETABLE(Image, imageTypes); +TYPETABLE(Sampler, samplerTypes); +TYPETABLE(SampledImage, sampledImageTypes); +TYPETABLE(Function, functionTypes); + +}; // namespace rdcspv #if ENABLED(ENABLE_UNIT_TESTS) @@ -848,10 +847,10 @@ TYPETABLE(SPIRVFunction, functionTypes); #include "spirv_common.h" #include "spirv_compile.h" -static void RemoveSection(std::vector &spirv, size_t offsets[SPIRVSection::Count][2], - SPIRVSection::Type section) +static void RemoveSection(std::vector &spirv, size_t offsets[rdcspv::Section::Count][2], + rdcspv::Section::Type section) { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); for(rdcspv::Iter it = ed.Begin(section), end = ed.End(section); it < end; it++) ed.Remove(it); @@ -865,20 +864,20 @@ static void RemoveSection(std::vector &spirv, size_t offsets[SPIRVSect // as padding to ensure no section is truly empty. size_t delta = oldLength - 4; - for(uint32_t s = section + 1; s < SPIRVSection::Count; s++) + for(uint32_t s = section + 1; s < rdcspv::Section::Count; s++) { offsets[s][0] -= delta; offsets[s][1] -= delta; } } -static void CheckSPIRV(SPIRVEditor &ed, size_t offsets[SPIRVSection::Count][2]) +static void CheckSPIRV(rdcspv::Editor &ed, size_t offsets[rdcspv::Section::Count][2]) { - for(uint32_t s = SPIRVSection::First; s < SPIRVSection::Count; s++) + for(uint32_t s = rdcspv::Section::First; s < rdcspv::Section::Count; s++) { INFO("Section " << s); - CHECK(ed.Begin((SPIRVSection::Type)s).offs() == offsets[s][0] / sizeof(uint32_t)); - CHECK(ed.End((SPIRVSection::Type)s).offs() == offsets[s][1] / sizeof(uint32_t)); + CHECK(ed.Begin((rdcspv::Section::Type)s).offs() == offsets[s][0] / sizeof(uint32_t)); + CHECK(ed.End((rdcspv::Section::Type)s).offs() == offsets[s][1] / sizeof(uint32_t)); } // should only be one entry point @@ -887,18 +886,18 @@ static void CheckSPIRV(SPIRVEditor &ed, size_t offsets[SPIRVSection::Count][2]) rdcspv::Id entryId = ed.GetEntries()[0].entryPoint; // check that the iterator places us precisely at the start of the functions section - CHECK(ed.GetID(entryId).offs() == ed.Begin(SPIRVSection::Functions).offs()); + CHECK(ed.GetID(entryId).offs() == ed.Begin(rdcspv::Section::Functions).offs()); } TEST_CASE("Test SPIR-V editor section handling", "[spirv]") { - InitSPIRVCompiler(); - RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler); + rdcspv::Init(); + RenderDoc::Inst().RegisterShutdownFunction(&rdcspv::Shutdown); - SPIRVCompilationSettings settings; + rdcspv::CompilationSettings settings; settings.entryPoint = "main"; - settings.lang = SPIRVSourceLanguage::VulkanGLSL; - settings.stage = SPIRVShaderStage::Fragment; + settings.lang = rdcspv::InputLanguage::VulkanGLSL; + settings.stage = rdcspv::ShaderStage::Fragment; // simple shader that has at least something in every section std::vector sources = { @@ -919,7 +918,7 @@ void main() { }; std::vector spirv; - std::string errors = CompileSPIRV(settings, sources, spirv); + std::string errors = rdcspv::Compile(settings, sources, spirv); INFO("SPIR-V compilation - " << errors); @@ -930,7 +929,7 @@ void main() { // they should be updated. // For convenience the offsets are in bytes (which spirv-dis uses) and are converted in the loop // in CheckSPIRV. - size_t offsets[SPIRVSection::Count][2] = { + size_t offsets[rdcspv::Section::Count][2] = { // Capabilities {0x14, 0x24}, // Extensions @@ -955,54 +954,54 @@ void main() { SECTION("Check that SPIR-V is correct with no changes") { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); CheckSPIRV(ed, offsets); } // we remove all sections we consider optional in arbitrary order. We don't care about keeping the // SPIR-V valid all we're testing is the section offsets are correct. - RemoveSection(spirv, offsets, SPIRVSection::Extensions); + RemoveSection(spirv, offsets, rdcspv::Section::Extensions); SECTION("Check with extensions removed") { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); CheckSPIRV(ed, offsets); } - RemoveSection(spirv, offsets, SPIRVSection::Debug); + RemoveSection(spirv, offsets, rdcspv::Section::Debug); SECTION("Check with debug removed") { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); CheckSPIRV(ed, offsets); } - RemoveSection(spirv, offsets, SPIRVSection::ExtInst); + RemoveSection(spirv, offsets, rdcspv::Section::ExtInst); SECTION("Check with extension imports removed") { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); CheckSPIRV(ed, offsets); } - RemoveSection(spirv, offsets, SPIRVSection::ExecutionMode); + RemoveSection(spirv, offsets, rdcspv::Section::ExecutionMode); SECTION("Check with execution mode removed") { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); CheckSPIRV(ed, offsets); } - RemoveSection(spirv, offsets, SPIRVSection::Annotations); + RemoveSection(spirv, offsets, rdcspv::Section::Annotations); SECTION("Check with annotations removed") { - SPIRVEditor ed(spirv); + rdcspv::Editor ed(spirv); CheckSPIRV(ed, offsets); } diff --git a/renderdoc/driver/shaders/spirv/spirv_editor.h b/renderdoc/driver/shaders/spirv/spirv_editor.h index 3a4a1afd4..5e3b2fe2a 100644 --- a/renderdoc/driver/shaders/spirv/spirv_editor.h +++ b/renderdoc/driver/shaders/spirv/spirv_editor.h @@ -34,37 +34,39 @@ #include "spirv_common.h" #include "spirv_op_helpers.h" -class SPIRVEditor; - -struct SPIRVBinding +namespace rdcspv { - SPIRVBinding() = default; - SPIRVBinding(uint32_t s, uint32_t b) : set(s), binding(b) {} +class Editor; + +struct Binding +{ + Binding() = default; + Binding(uint32_t s, uint32_t b) : set(s), binding(b) {} uint32_t set = 0; uint32_t binding = ~0U; - bool operator<(const SPIRVBinding &o) const + bool operator<(const Binding &o) const { if(set != o.set) return set < o.set; return binding < o.binding; } - bool operator!=(const SPIRVBinding &o) const { return !operator==(o); } - bool operator==(const SPIRVBinding &o) const { return set == o.set && binding == o.binding; } + bool operator!=(const Binding &o) const { return !operator==(o); } + bool operator==(const Binding &o) const { return set == o.set && binding == o.binding; } }; -struct SPIRVScalar +struct Scalar { - SPIRVScalar() : type(rdcspv::Op::Max), width(0), signedness(false) {} - constexpr SPIRVScalar(rdcspv::Op t, uint32_t w, bool s) : type(t), width(w), signedness(s) {} - SPIRVScalar(rdcspv::Iter op); + Scalar() : type(Op::Max), width(0), signedness(false) {} + constexpr Scalar(Op t, uint32_t w, bool s) : type(t), width(w), signedness(s) {} + Scalar(Iter op); - rdcspv::Op type; + Op type; uint32_t width; bool signedness; - bool operator<(const SPIRVScalar &o) const + bool operator<(const Scalar &o) const { if(type != o.type) return type < o.type; @@ -73,125 +75,121 @@ struct SPIRVScalar return width < o.width; } - bool operator!=(const SPIRVScalar &o) const { return !operator==(o); } - bool operator==(const SPIRVScalar &o) const + bool operator!=(const Scalar &o) const { return !operator==(o); } + bool operator==(const Scalar &o) const { return type == o.type && width == o.width && signedness == o.signedness; } - rdcspv::Operation decl(SPIRVEditor &editor) const + Operation decl(Editor &editor) const { - if(type == rdcspv::Op::TypeVoid) - return rdcspv::OpTypeVoid(rdcspv::Id()); - else if(type == rdcspv::Op::TypeBool) - return rdcspv::OpTypeBool(rdcspv::Id()); - else if(type == rdcspv::Op::TypeFloat) - return rdcspv::OpTypeFloat(rdcspv::Id(), width); - else if(type == rdcspv::Op::TypeInt) - return rdcspv::OpTypeInt(rdcspv::Id(), width, signedness ? 1U : 0U); + if(type == Op::TypeVoid) + return OpTypeVoid(Id()); + else if(type == Op::TypeBool) + return OpTypeBool(Id()); + else if(type == Op::TypeFloat) + return OpTypeFloat(Id(), width); + else if(type == Op::TypeInt) + return OpTypeInt(Id(), width, signedness ? 1U : 0U); else - return rdcspv::OpNop(); + return OpNop(); } }; -// helper to create SPIRVScalar objects for known types +// helper to create Scalar objects for known types template -inline constexpr SPIRVScalar scalar(); +inline constexpr Scalar scalar(); -#define SCALAR_TYPE(ctype, op, width, sign) \ - template <> \ - inline constexpr SPIRVScalar scalar() \ - { \ - return SPIRVScalar(op, width, sign); \ +#define SCALAR_TYPE(ctype, op, width, sign) \ + template <> \ + inline constexpr Scalar scalar() \ + { \ + return Scalar(op, width, sign); \ } -SCALAR_TYPE(void, rdcspv::Op::TypeVoid, 0, false); -SCALAR_TYPE(bool, rdcspv::Op::TypeBool, 0, false); -SCALAR_TYPE(uint8_t, rdcspv::Op::TypeInt, 8, false); -SCALAR_TYPE(uint16_t, rdcspv::Op::TypeInt, 16, false); -SCALAR_TYPE(uint32_t, rdcspv::Op::TypeInt, 32, false); -SCALAR_TYPE(uint64_t, rdcspv::Op::TypeInt, 64, false); -SCALAR_TYPE(int8_t, rdcspv::Op::TypeInt, 8, true); -SCALAR_TYPE(int16_t, rdcspv::Op::TypeInt, 16, true); -SCALAR_TYPE(int32_t, rdcspv::Op::TypeInt, 32, true); -SCALAR_TYPE(int64_t, rdcspv::Op::TypeInt, 64, true); -SCALAR_TYPE(float, rdcspv::Op::TypeFloat, 32, false); -SCALAR_TYPE(double, rdcspv::Op::TypeFloat, 64, false); +SCALAR_TYPE(void, Op::TypeVoid, 0, false); +SCALAR_TYPE(bool, Op::TypeBool, 0, false); +SCALAR_TYPE(uint8_t, Op::TypeInt, 8, false); +SCALAR_TYPE(uint16_t, Op::TypeInt, 16, false); +SCALAR_TYPE(uint32_t, Op::TypeInt, 32, false); +SCALAR_TYPE(uint64_t, Op::TypeInt, 64, false); +SCALAR_TYPE(int8_t, Op::TypeInt, 8, true); +SCALAR_TYPE(int16_t, Op::TypeInt, 16, true); +SCALAR_TYPE(int32_t, Op::TypeInt, 32, true); +SCALAR_TYPE(int64_t, Op::TypeInt, 64, true); +SCALAR_TYPE(float, Op::TypeFloat, 32, false); +SCALAR_TYPE(double, Op::TypeFloat, 64, false); -struct SPIRVVector +struct Vector { - SPIRVVector(const SPIRVScalar &s, uint32_t c) : scalar(s), count(c) {} - SPIRVScalar scalar; + Vector(const Scalar &s, uint32_t c) : scalar(s), count(c) {} + Scalar scalar; uint32_t count; - bool operator<(const SPIRVVector &o) const + bool operator<(const Vector &o) const { if(scalar != o.scalar) return scalar < o.scalar; return count < o.count; } - bool operator!=(const SPIRVVector &o) const { return !operator==(o); } - bool operator==(const SPIRVVector &o) const { return scalar == o.scalar && count == o.count; } - rdcspv::Operation decl(SPIRVEditor &editor) const; + bool operator!=(const Vector &o) const { return !operator==(o); } + bool operator==(const Vector &o) const { return scalar == o.scalar && count == o.count; } + Operation decl(Editor &editor) const; }; -struct SPIRVMatrix +struct Matrix { - SPIRVMatrix(const SPIRVVector &v, uint32_t c) : vector(v), count(c) {} - SPIRVVector vector; + Matrix(const Vector &v, uint32_t c) : vector(v), count(c) {} + Vector vector; uint32_t count; - bool operator<(const SPIRVMatrix &o) const + bool operator<(const Matrix &o) const { if(vector != o.vector) return vector < o.vector; return count < o.count; } - bool operator!=(const SPIRVMatrix &o) const { return !operator==(o); } - bool operator==(const SPIRVMatrix &o) const { return vector == o.vector && count == o.count; } - rdcspv::Operation decl(SPIRVEditor &editor) const; + bool operator!=(const Matrix &o) const { return !operator==(o); } + bool operator==(const Matrix &o) const { return vector == o.vector && count == o.count; } + Operation decl(Editor &editor) const; }; -struct SPIRVPointer +struct Pointer { - SPIRVPointer(rdcspv::Id b, rdcspv::StorageClass s) : baseId(b), storage(s) {} - rdcspv::Id baseId; - rdcspv::StorageClass storage; + Pointer(Id b, StorageClass s) : baseId(b), storage(s) {} + Id baseId; + StorageClass storage; - bool operator<(const SPIRVPointer &o) const + bool operator<(const Pointer &o) const { if(baseId != o.baseId) return baseId < o.baseId; return storage < o.storage; } - bool operator!=(const SPIRVPointer &o) const { return !operator==(o); } - bool operator==(const SPIRVPointer &o) const - { - return baseId == o.baseId && storage == o.storage; - } - rdcspv::Operation decl(SPIRVEditor &editor) const; + bool operator!=(const Pointer &o) const { return !operator==(o); } + bool operator==(const Pointer &o) const { return baseId == o.baseId && storage == o.storage; } + Operation decl(Editor &editor) const; }; -struct SPIRVImage +struct Image { - SPIRVImage(SPIRVScalar ret, rdcspv::Dim d, uint32_t dp, uint32_t ar, uint32_t m, uint32_t samp, - rdcspv::ImageFormat f) + Image(Scalar ret, Dim d, uint32_t dp, uint32_t ar, uint32_t m, uint32_t samp, ImageFormat f) : retType(ret), dim(d), depth(dp), arrayed(ar), ms(m), sampled(samp), format(f) { } - SPIRVScalar retType; - rdcspv::Dim dim; + Scalar retType; + Dim dim; uint32_t depth; uint32_t arrayed; uint32_t ms; uint32_t sampled; - rdcspv::ImageFormat format; + ImageFormat format; - bool operator<(const SPIRVImage &o) const + bool operator<(const Image &o) const { if(retType != o.retType) return retType < o.retType; @@ -207,66 +205,64 @@ struct SPIRVImage return sampled < o.sampled; return format < o.format; } - bool operator!=(const SPIRVImage &o) const { return !operator==(o); } - bool operator==(const SPIRVImage &o) const + bool operator!=(const Image &o) const { return !operator==(o); } + bool operator==(const Image &o) const { return retType == o.retType && dim == o.dim && depth == o.depth && arrayed == o.arrayed && ms == o.ms && sampled == o.sampled && format == o.format; } - rdcspv::Operation decl(SPIRVEditor &editor) const; + Operation decl(Editor &editor) const; }; -struct SPIRVSampler +struct Sampler { // no properties, all sampler types are equal - bool operator<(const SPIRVSampler &o) const { return false; } - bool operator!=(const SPIRVSampler &o) const { return false; } - bool operator==(const SPIRVSampler &o) const { return true; } - rdcspv::Operation decl(SPIRVEditor &editor) const; + bool operator<(const Sampler &o) const { return false; } + bool operator!=(const Sampler &o) const { return false; } + bool operator==(const Sampler &o) const { return true; } + Operation decl(Editor &editor) const; }; -struct SPIRVSampledImage +struct SampledImage { - SPIRVSampledImage(rdcspv::Id b) : baseId(b) {} - rdcspv::Id baseId; + SampledImage(Id b) : baseId(b) {} + Id baseId; - bool operator<(const SPIRVSampledImage &o) const { return baseId < o.baseId; } - bool operator!=(const SPIRVSampledImage &o) const { return !operator==(o); } - bool operator==(const SPIRVSampledImage &o) const { return baseId == o.baseId; } - rdcspv::Operation decl(SPIRVEditor &editor) const; + bool operator<(const SampledImage &o) const { return baseId < o.baseId; } + bool operator!=(const SampledImage &o) const { return !operator==(o); } + bool operator==(const SampledImage &o) const { return baseId == o.baseId; } + Operation decl(Editor &editor) const; }; -struct SPIRVFunction +struct Function { - SPIRVFunction(rdcspv::Id ret, const rdcarray &args) : returnId(ret), argumentIds(args) - { - } - rdcspv::Id returnId; - rdcarray argumentIds; + Function(Id ret, const rdcarray &args) : returnId(ret), argumentIds(args) {} + Id returnId; + rdcarray argumentIds; - bool operator<(const SPIRVFunction &o) const + bool operator<(const Function &o) const { if(returnId != o.returnId) return returnId < o.returnId; return argumentIds < o.argumentIds; } - bool operator!=(const SPIRVFunction &o) const { return !operator==(o); } - bool operator==(const SPIRVFunction &o) const + bool operator!=(const Function &o) const { return !operator==(o); } + bool operator==(const Function &o) const { return returnId == o.returnId && argumentIds == o.argumentIds; } - rdcspv::Operation decl(SPIRVEditor &editor) const; + Operation decl(Editor &editor) const; }; -template -using SPIRVTypeId = std::pair; +template +using TypeId = std::pair; -template -using SPIRVTypeIds = std::vector>; +template +using TypeIds = std::vector>; // hack around enum class being useless for array indices :( -struct SPIRVSection +struct Section { enum Type { @@ -289,94 +285,87 @@ struct SPIRVSection }; }; -class SPIRVEditor +class Editor { public: - SPIRVEditor(std::vector &spirvWords); - ~SPIRVEditor() { StripNops(); } + Editor(std::vector &spirvWords); + ~Editor() { StripNops(); } void StripNops(); - rdcspv::Id MakeId(); + Id MakeId(); - void AddOperation(rdcspv::Iter iter, const rdcspv::Operation &op); + void AddOperation(Iter iter, const Operation &op); // callbacks to allow us to update our internal structures over changes // called before any modifications are made. Removes the operation from internal structures. - void PreModify(rdcspv::Iter iter) { UnregisterOp(iter); } + void PreModify(Iter iter) { UnregisterOp(iter); } // called after any modifications, re-adds the operation to internal structures with its new // properties - void PostModify(rdcspv::Iter iter) { RegisterOp(iter); } + void PostModify(Iter iter) { RegisterOp(iter); } // removed an operation and replaces it with nops - void Remove(rdcspv::Iter iter) + void Remove(Iter iter) { UnregisterOp(iter); iter.nopRemove(); } - void SetName(rdcspv::Id id, const char *name); - void AddDecoration(const rdcspv::Operation &op); - void AddCapability(rdcspv::Capability cap); + void SetName(Id id, const char *name); + void AddDecoration(const Operation &op); + void AddCapability(Capability cap); void AddExtension(const rdcstr &extension); - void AddExecutionMode(const rdcspv::Operation &mode); - rdcspv::Id ImportExtInst(const char *setname); - rdcspv::Id AddType(const rdcspv::Operation &op); - rdcspv::Id AddVariable(const rdcspv::Operation &op); - rdcspv::Id AddConstant(const rdcspv::Operation &op); - void AddFunction(const rdcspv::Operation *ops, size_t count); + void AddExecutionMode(const Operation &mode); + Id ImportExtInst(const char *setname); + Id AddType(const Operation &op); + Id AddVariable(const Operation &op); + Id AddConstant(const Operation &op); + void AddFunction(const Operation *ops, size_t count); - rdcspv::Iter GetID(rdcspv::Id id); + Iter GetID(Id id); // the entry point has 'two' opcodes, the entrypoint declaration and the function. // This returns the first, GetID returns the second. - rdcspv::Iter GetEntry(rdcspv::Id id); - rdcspv::Iter Begin(SPIRVSection::Type section) - { - return rdcspv::Iter(spirv, sections[section].startOffset); - } - rdcspv::Iter End(SPIRVSection::Type section) - { - return rdcspv::Iter(spirv, sections[section].endOffset); - } - + Iter GetEntry(Id id); + Iter Begin(Section::Type section) { return Iter(spirv, sections[section].startOffset); } + Iter End(Section::Type section) { return Iter(spirv, sections[section].endOffset); } // fetches the id of this type. If it exists already the old ID will be returned, otherwise it // will be declared and the new ID returned - template - rdcspv::Id DeclareType(const SPIRVType &t) + template + Id DeclareType(const Type &t) { - std::map &table = GetTable(); + std::map &table = GetTable(); auto it = table.lower_bound(t); if(it != table.end() && it->first == t) return it->second; - rdcspv::Operation decl = t.decl(*this); - rdcspv::Id id = MakeId(); + Operation decl = t.decl(*this); + Id id = MakeId(); decl[1] = id.value(); AddType(decl); - table.insert(it, std::pair(t, id)); + table.insert(it, std::pair(t, id)); return id; } - template - rdcspv::Id GetType(const SPIRVType &t) + template + Id GetType(const Type &t) { - std::map &table = GetTable(); + std::map &table = GetTable(); auto it = table.find(t); if(it != table.end()) return it->second; - return rdcspv::Id(); + return Id(); } - template - SPIRVTypeIds GetTypes() + template + TypeIds GetTypes() { - std::map &table = GetTable(); + std::map &table = GetTable(); - SPIRVTypeIds ret; + TypeIds ret; for(auto it = table.begin(); it != table.end(); ++it) ret.push_back(*it); @@ -384,47 +373,47 @@ public: return ret; } - template - const std::map &GetTypeInfo() const + template + const std::map &GetTypeInfo() const { - return GetTable(); + return GetTable(); } - SPIRVBinding GetBinding(rdcspv::Id id) const + Binding GetBinding(Id id) const { auto it = bindings.find(id); if(it == bindings.end()) - return SPIRVBinding(); + return Binding(); return it->second; } - const std::set &GetStructTypes() const { return structTypes; } - rdcspv::Id DeclareStructType(const std::vector &members); + const std::set &GetStructTypes() const { return structTypes; } + Id DeclareStructType(const std::vector &members); // helper for AddConstant template - rdcspv::Id AddConstantImmediate(T t) + Id AddConstantImmediate(T t) { - rdcspv::Id typeId = DeclareType(scalar()); + Id typeId = DeclareType(scalar()); std::vector words = {typeId.value(), MakeId().value()}; words.insert(words.end(), sizeof(T) / 4, 0U); memcpy(&words[2], &t, sizeof(T)); - return AddConstant(rdcspv::Operation(rdcspv::Op::Constant, words)); + return AddConstant(Operation(Op::Constant, words)); } // accessors to structs/vectors of data - const std::vector &GetEntries() { return entries; } - const std::vector &GetVariables() { return variables; } - const std::vector &GetFunctions() { return functions; } - rdcspv::Id GetIDType(rdcspv::Id id) { return idTypes[id.value()]; } + const std::vector &GetEntries() { return entries; } + const std::vector &GetVariables() { return variables; } + const std::vector &GetFunctions() { return functions; } + Id GetIDType(Id id) { return idTypes[id.value()]; } private: inline void addWords(size_t offs, size_t num) { addWords(offs, (int32_t)num); } void addWords(size_t offs, int32_t num); - void RegisterOp(rdcspv::Iter iter); - void UnregisterOp(rdcspv::Iter iter); + void RegisterOp(Iter iter); + void UnregisterOp(Iter iter); struct LogicalSection { @@ -432,47 +421,47 @@ private: size_t endOffset = 0; }; - LogicalSection sections[SPIRVSection::Count]; + LogicalSection sections[Section::Count]; - rdcspv::AddressingModel addressmodel; - rdcspv::MemoryModel memorymodel; + AddressingModel addressmodel; + MemoryModel memorymodel; - std::vector decorations; + std::vector decorations; - std::map bindings; + std::map bindings; std::vector idOffsets; - std::vector idTypes; + std::vector idTypes; - std::vector entries; - std::vector variables; - std::vector functions; + std::vector entries; + std::vector variables; + std::vector functions; std::set extensions; - std::set capabilities; + std::set capabilities; - std::map extSets; + std::map extSets; - std::map scalarTypes; - std::map vectorTypes; - std::map matrixTypes; - std::map pointerTypes; - std::map imageTypes; - std::map samplerTypes; - std::map sampledImageTypes; - std::map functionTypes; + std::map scalarTypes; + std::map vectorTypes; + std::map matrixTypes; + std::map pointerTypes; + std::map imageTypes; + std::map samplerTypes; + std::map sampledImageTypes; + std::map functionTypes; - std::set structTypes; + std::set structTypes; - template - std::map &GetTable(); + template + std::map &GetTable(); - template - const std::map &GetTable() const; + template + const std::map &GetTable() const; std::vector &spirv; }; -inline bool operator<(const rdcspv::OpDecorate &a, const rdcspv::OpDecorate &b) +inline bool operator<(const OpDecorate &a, const OpDecorate &b) { if(a.target != b.target) return a.target < b.target; @@ -482,7 +471,9 @@ inline bool operator<(const rdcspv::OpDecorate &a, const rdcspv::OpDecorate &b) return memcmp(&a.decoration, &b.decoration, sizeof(a.decoration)) < 0; } -inline bool operator==(const rdcspv::OpDecorate &a, const rdcspv::OpDecorate &b) +inline bool operator==(const OpDecorate &a, const OpDecorate &b) { return a.target == b.target && !memcmp(&a.decoration, &b.decoration, sizeof(a.decoration)); -} \ No newline at end of file +} + +}; // namespace rdcspv \ No newline at end of file diff --git a/renderdoc/driver/shaders/spirv/spirv_reflect.cpp b/renderdoc/driver/shaders/spirv/spirv_reflect.cpp index bf547cf3f..e09b503e5 100644 --- a/renderdoc/driver/shaders/spirv/spirv_reflect.cpp +++ b/renderdoc/driver/shaders/spirv/spirv_reflect.cpp @@ -57,7 +57,7 @@ void FillSpecConstantVariables(const rdcarray &invars, void AddXFBAnnotations(const ShaderReflection &refl, const SPIRVPatchData &patchData, const char *entryName, std::vector &modSpirv, uint32_t &xfbStride) { - SPIRVEditor editor(modSpirv); + rdcspv::Editor editor(modSpirv); rdcarray outsig = refl.outputSignature; std::vector outpatch = patchData.outputs; @@ -74,8 +74,8 @@ void AddXFBAnnotations(const ShaderReflection &refl, const SPIRVPatchData &patch bool hasXFB = false; - for(rdcspv::Iter it = editor.Begin(SPIRVSection::ExecutionMode); - it < editor.End(SPIRVSection::ExecutionMode); ++it) + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::ExecutionMode); + it < editor.End(rdcspv::Section::ExecutionMode); ++it) { rdcspv::OpExecutionMode execMode(it); @@ -88,8 +88,8 @@ void AddXFBAnnotations(const ShaderReflection &refl, const SPIRVPatchData &patch if(hasXFB) { - for(rdcspv::Iter it = editor.Begin(SPIRVSection::Annotations); - it < editor.End(SPIRVSection::Annotations); ++it) + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Annotations); + it < editor.End(rdcspv::Section::Annotations); ++it) { // remove any existing xfb decorations if(it.opcode() == rdcspv::Op::Decorate) @@ -208,15 +208,15 @@ TEST_CASE("Validate SPIR-V reflection", "[spirv][reflection]") auto compiler = [&type](ShaderStage stage, const std::string &source, const std::string &entryPoint, ShaderReflection &refl, ShaderBindpointMapping &mapping) { - InitSPIRVCompiler(); - RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler); + rdcspv::Init(); + RenderDoc::Inst().RegisterShutdownFunction(&rdcspv::Shutdown); std::vector spirv; - SPIRVCompilationSettings settings(type == ShaderType::eShaderVulkan - ? SPIRVSourceLanguage::VulkanGLSL - : SPIRVSourceLanguage::OpenGLGLSL, - SPIRVShaderStage(stage)); - std::string errors = CompileSPIRV(settings, {source}, spirv); + rdcspv::CompilationSettings settings(type == ShaderType::eShaderVulkan + ? rdcspv::InputLanguage::VulkanGLSL + : rdcspv::InputLanguage::OpenGLGLSL, + rdcspv::ShaderStage(stage)); + std::string errors = rdcspv::Compile(settings, {source}, spirv); INFO("SPIR-V compile output: " << errors); diff --git a/renderdoc/driver/vulkan/vk_bindless_feedback.cpp b/renderdoc/driver/vulkan/vk_bindless_feedback.cpp index 644a280c6..094aba3a3 100644 --- a/renderdoc/driver/vulkan/vk_bindless_feedback.cpp +++ b/renderdoc/driver/vulkan/vk_bindless_feedback.cpp @@ -36,15 +36,15 @@ struct feedbackData }; void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, - const std::map &offsetMap, VkDeviceAddress addr, + const std::map &offsetMap, VkDeviceAddress addr, std::vector &modSpirv) { - SPIRVEditor editor(modSpirv); + rdcspv::Editor editor(modSpirv); const bool useBufferAddress = (addr != 0); - rdcspv::Id uint32ID = editor.DeclareType(scalar()); - rdcspv::Id int32ID = editor.DeclareType(scalar()); + rdcspv::Id uint32ID = editor.DeclareType(rdcspv::scalar()); + rdcspv::Id int32ID = editor.DeclareType(rdcspv::scalar()); rdcspv::Id uint64ID, int64ID; rdcspv::Id uint32StructID; rdcspv::Id funcParamType; @@ -52,8 +52,8 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, if(useBufferAddress) { // declare the int64 types we'll need - uint64ID = editor.DeclareType(scalar()); - int64ID = editor.DeclareType(scalar()); + uint64ID = editor.DeclareType(rdcspv::scalar()); + int64ID = editor.DeclareType(rdcspv::scalar()); uint32StructID = editor.AddType(rdcspv::OpTypeStruct(editor.MakeId(), {uint32ID})); @@ -93,7 +93,7 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, continue; // get this variable's binding info - SPIRVBinding bind = editor.GetBinding(var.result); + rdcspv::Binding bind = editor.GetBinding(var.result); // if this is one of the bindings we care about auto it = offsetMap.find(bind); @@ -132,7 +132,7 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, editor.AddExtension("SPV_EXT_physical_storage_buffer"); // change the memory model to physical storage buffer 64 - rdcspv::Iter it = editor.Begin(SPIRVSection::MemoryModel); + rdcspv::Iter it = editor.Begin(rdcspv::Section::MemoryModel); rdcspv::OpMemoryModel model(it); model.addressingModel = rdcspv::AddressingModel::PhysicalStorageBuffer64EXT; it = model; @@ -144,7 +144,7 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, // declare the address constants and make our pointers physical storage buffer pointers bufferAddressConst = editor.AddConstantImmediate(addr); uint32ptrtype = - editor.DeclareType(SPIRVPointer(uint32ID, rdcspv::StorageClass::PhysicalStorageBufferEXT)); + editor.DeclareType(rdcspv::Pointer(uint32ID, rdcspv::StorageClass::PhysicalStorageBufferEXT)); editor.SetName(bufferAddressConst, "__rd_feedbackAddress"); @@ -155,12 +155,12 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, { // the pointers are uniform pointers rdcspv::Id bufptrtype = - editor.DeclareType(SPIRVPointer(uint32StructID, rdcspv::StorageClass::Uniform)); - uint32ptrtype = editor.DeclareType(SPIRVPointer(uint32ID, rdcspv::StorageClass::Uniform)); + editor.DeclareType(rdcspv::Pointer(uint32StructID, rdcspv::StorageClass::Uniform)); + uint32ptrtype = editor.DeclareType(rdcspv::Pointer(uint32ID, rdcspv::StorageClass::Uniform)); // patch all bindings up by 1 - for(rdcspv::Iter it = editor.Begin(SPIRVSection::Annotations), - end = editor.End(SPIRVSection::Annotations); + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Annotations), + end = editor.End(rdcspv::Section::Annotations); it < end; ++it) { // we will use descriptor set 0 for our own purposes if we don't have a buffer address. @@ -202,9 +202,9 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, rdcspv::Id semantics = editor.AddConstantImmediate(0U); rdcspv::Id uint32shift = editor.AddConstantImmediate(2U); - std::map intTypeLookup; + std::map intTypeLookup; - for(auto scalarType : editor.GetTypeInfo()) + for(auto scalarType : editor.GetTypeInfo()) if(scalarType.first.type == rdcspv::Op::TypeInt) intTypeLookup[scalarType.second] = scalarType.first; @@ -218,7 +218,7 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, } } - SPIRVTypeIds funcTypes = editor.GetTypes(); + rdcspv::TypeIds funcTypes = editor.GetTypes(); // functions that have been patched with annotation & extra function parameters if needed std::set patchedFunctions; @@ -254,11 +254,11 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, rdcspv::OpFunction func(it); // find the function's type declaration, add the necessary arguments, redeclare and patch it - for(const SPIRVTypeId &funcType : funcTypes) + for(const rdcspv::TypeId &funcType : funcTypes) { if(funcType.second == func.functionType) { - SPIRVFunction patchedFuncType = funcType.first; + rdcspv::Function patchedFuncType = funcType.first; for(size_t i = 0; i < patchArgIndices.size(); i++) patchedFuncType.argumentIds.push_back(funcParamType); @@ -412,7 +412,7 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, indexType = uint32ID; } - SPIRVScalar indexTypeData = scalar(); + rdcspv::Scalar indexTypeData = rdcspv::scalar(); auto indexTypeIt = intTypeLookup.find(indexType); if(indexTypeIt != intTypeLookup.end()) @@ -441,7 +441,7 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, if(indexTypeData.width != targetIndexWidth) { rdcspv::Id extendedtype = - editor.DeclareType(SPIRVScalar(rdcspv::Op::TypeInt, targetIndexWidth, false)); + editor.DeclareType(rdcspv::Scalar(rdcspv::Op::TypeInt, targetIndexWidth, false)); rdcspv::Id extendedindex = editor.MakeId(); editor.AddOperation(it, rdcspv::OpUConvert(extendedtype, extendedindex, index)); it++; @@ -548,13 +548,13 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) VkDeviceSize feedbackStorageSize = 0; - std::map offsetMap; + std::map offsetMap; { const std::vector &descSetLayoutIds = creationInfo.m_PipelineLayout[pipeInfo.layout].descSetLayouts; - SPIRVBinding key; + rdcspv::Binding key; for(size_t set = 0; set < descSetLayoutIds.size(); set++) { diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 08c25da4c..90f1a323b 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -111,8 +111,8 @@ WrappedVulkan::WrappedVulkan() : m_RenderState(this, &m_CreationInfo) m_SectionVersion = VkInitParams::CurrentVersion; - InitSPIRVCompiler(); - RenderDoc::Inst().RegisterShutdownFunction(&ShutdownSPIRVCompiler); + rdcspv::Init(); + RenderDoc::Inst().RegisterShutdownFunction(&rdcspv::Shutdown); m_Replay.SetDriver(this); diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp index 00f73d123..1d518fcbe 100644 --- a/renderdoc/driver/vulkan/vk_debug.cpp +++ b/renderdoc/driver/vulkan/vk_debug.cpp @@ -2475,9 +2475,9 @@ void VulkanReplay::HistogramMinMax::Init(WrappedVulkan *driver, VkDescriptorPool for(size_t i = 0; i < ARRAY_COUNT(m_HistogramDescSet); i++) CREATE_OBJECT(m_HistogramDescSet[i], descriptorPool, m_HistogramDescSetLayout); - SPIRVCompilationSettings compileSettings; - compileSettings.lang = SPIRVSourceLanguage::VulkanGLSL; - compileSettings.stage = SPIRVShaderStage::Compute; + rdcspv::CompilationSettings compileSettings; + compileSettings.lang = rdcspv::InputLanguage::VulkanGLSL; + compileSettings.stage = rdcspv::ShaderStage::Compute; // type max is one higher than the last RESTYPE, and RESTYPES are 1-indexed RDCCOMPILE_ASSERT(RESTYPE_TEXTYPEMAX == ARRAY_COUNT(m_MinMaxTilePipe), diff --git a/renderdoc/driver/vulkan/vk_debug.h b/renderdoc/driver/vulkan/vk_debug.h index 8a8f4f937..61d2d246f 100644 --- a/renderdoc/driver/vulkan/vk_debug.h +++ b/renderdoc/driver/vulkan/vk_debug.h @@ -46,8 +46,6 @@ struct MeshDisplayPipelines VkPipeline pipes[ePipe_Count] = {}; }; -struct SPIRVCompilationSettings; - struct CopyPixelParams; struct PixelHistoryResources; diff --git a/renderdoc/driver/vulkan/vk_postvs.cpp b/renderdoc/driver/vulkan/vk_postvs.cpp index b0cb6410d..93e801828 100644 --- a/renderdoc/driver/vulkan/vk_postvs.cpp +++ b/renderdoc/driver/vulkan/vk_postvs.cpp @@ -54,15 +54,15 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV uint32_t numViews, std::vector &modSpirv, uint32_t &bufStride) { - SPIRVEditor editor(modSpirv); + rdcspv::Editor editor(modSpirv); uint32_t numInputs = (uint32_t)refl.inputSignature.size(); uint32_t numOutputs = (uint32_t)refl.outputSignature.size(); RDCASSERT(numOutputs > 0); - for(rdcspv::Iter it = editor.Begin(SPIRVSection::Annotations), - end = editor.End(SPIRVSection::Annotations); + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Annotations), + end = editor.End(rdcspv::Section::Annotations); it < end; ++it) { // we will use descriptor set 0 bindings 0..N for our own purposes. @@ -125,8 +125,8 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV std::map typeReplacements; // rewrite any inputs and outputs to be private storage class - for(rdcspv::Iter it = editor.Begin(SPIRVSection::TypesVariablesConstants), - end = editor.End(SPIRVSection::TypesVariablesConstants); + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::TypesVariablesConstants), + end = editor.End(rdcspv::Section::TypesVariablesConstants); it < end; ++it) { // rewrite any input/output variables to private, and build up inputs/outputs list @@ -153,7 +153,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV if(id) { - SPIRVPointer privPtr(ptr.type, rdcspv::StorageClass::Private); + rdcspv::Pointer privPtr(ptr.type, rdcspv::StorageClass::Private); rdcspv::Id origId = editor.GetType(privPtr); @@ -279,7 +279,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV } } - for(rdcspv::Iter it = editor.Begin(SPIRVSection::Functions); it; ++it) + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Functions); it; ++it) { // identify functions with result types we might want to replace if(it.opcode() == rdcspv::Op::Function || it.opcode() == rdcspv::Op::FunctionParameter || @@ -301,8 +301,8 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV } // detect builtin inputs or outputs, and remove builtin decorations - for(rdcspv::Iter it = editor.Begin(SPIRVSection::Annotations), - end = editor.End(SPIRVSection::Annotations); + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Annotations), + end = editor.End(rdcspv::Section::Annotations); it < end; ++it) { if(it.opcode() == rdcspv::Op::Decorate) @@ -311,7 +311,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV // remove any builtin decorations if(decorate.decoration == rdcspv::Decoration::BuiltIn) { - // we don't have to do anything, the ID mapping is in the SPIRVPatchData, so just discard + // we don't have to do anything, the ID mapping is in the rdcspv::PatchData, so just discard // the // location information editor.Remove(it); @@ -323,7 +323,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV } else if(decorate.decoration == rdcspv::Decoration::Location) { - // we don't have to do anything, the ID mapping is in the SPIRVPatchData, so just discard + // we don't have to do anything, the ID mapping is in the rdcspv::PatchData, so just discard // the location information editor.Remove(it); } @@ -358,7 +358,8 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV RDCASSERT(entryID); - for(rdcspv::Iter it = editor.Begin(SPIRVSection::Debug), end2 = editor.End(SPIRVSection::Debug); + for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Debug), + end2 = editor.End(rdcspv::Section::Debug); it < end2; ++it) { if(it.opcode() == rdcspv::Op::Name) @@ -394,28 +395,30 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV // base type - either a scalar or a vector, since matrix outputs are decayed to vectors { - SPIRVScalar scalarType = scalar(); + rdcspv::Scalar scalarType = rdcspv::scalar(); if(refl.outputSignature[i].compType == CompType::UInt) - scalarType = scalar(); + scalarType = rdcspv::scalar(); else if(refl.outputSignature[i].compType == CompType::SInt) - scalarType = scalar(); + scalarType = rdcspv::scalar(); else if(refl.outputSignature[i].compType == CompType::Float) - scalarType = scalar(); + scalarType = rdcspv::scalar(); else if(refl.outputSignature[i].compType == CompType::Double) - scalarType = scalar(); + scalarType = rdcspv::scalar(); - io.vec4ID = editor.DeclareType(SPIRVVector(scalarType, 4)); + io.vec4ID = editor.DeclareType(rdcspv::Vector(scalarType, 4)); if(refl.outputSignature[i].compCount > 1) io.basetypeID = - editor.DeclareType(SPIRVVector(scalarType, refl.outputSignature[i].compCount)); + editor.DeclareType(rdcspv::Vector(scalarType, refl.outputSignature[i].compCount)); else io.basetypeID = editor.DeclareType(scalarType); } - io.uniformPtrID = editor.DeclareType(SPIRVPointer(io.basetypeID, rdcspv::StorageClass::Uniform)); - io.privatePtrID = editor.DeclareType(SPIRVPointer(io.basetypeID, rdcspv::StorageClass::Private)); + io.uniformPtrID = + editor.DeclareType(rdcspv::Pointer(io.basetypeID, rdcspv::StorageClass::Uniform)); + io.privatePtrID = + editor.DeclareType(rdcspv::Pointer(io.basetypeID, rdcspv::StorageClass::Private)); RDCASSERT(io.basetypeID && io.vec4ID && io.constID && io.privatePtrID && io.uniformPtrID, io.basetypeID, io.vec4ID, io.constID, io.privatePtrID, io.uniformPtrID); @@ -433,43 +436,45 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV io.variableID = rdcspv::Id::fromWord(patchData.inputs[i].ID); - SPIRVScalar scalarType = scalar(); + rdcspv::Scalar scalarType = rdcspv::scalar(); // base type - either a scalar or a vector, since matrix outputs are decayed to vectors if(refl.inputSignature[i].compType == CompType::UInt) { - scalarType = scalar(); + scalarType = rdcspv::scalar(); io.tbuffer = tbuffer_uint; } else if(refl.inputSignature[i].compType == CompType::SInt) { - scalarType = scalar(); + scalarType = rdcspv::scalar(); io.tbuffer = tbuffer_sint; } else if(refl.inputSignature[i].compType == CompType::Float) { - scalarType = scalar(); + scalarType = rdcspv::scalar(); io.tbuffer = tbuffer_float; } else if(refl.inputSignature[i].compType == CompType::Double) { - scalarType = scalar(); + scalarType = rdcspv::scalar(); // doubles are loaded packed from a uint tbuffer io.tbuffer = tbuffer_uint; } // doubles are loaded as uvec4 and then packed in pairs, so we need to declare vec4ID as uvec4 if(refl.inputSignature[i].compType == CompType::Double) - io.vec4ID = editor.DeclareType(SPIRVVector(scalar(), 4)); + io.vec4ID = editor.DeclareType(rdcspv::Vector(rdcspv::scalar(), 4)); else - io.vec4ID = editor.DeclareType(SPIRVVector(scalarType, 4)); + io.vec4ID = editor.DeclareType(rdcspv::Vector(scalarType, 4)); if(refl.inputSignature[i].compCount > 1) - io.basetypeID = editor.DeclareType(SPIRVVector(scalarType, refl.inputSignature[i].compCount)); + io.basetypeID = + editor.DeclareType(rdcspv::Vector(scalarType, refl.inputSignature[i].compCount)); else io.basetypeID = editor.DeclareType(scalarType); - io.privatePtrID = editor.DeclareType(SPIRVPointer(io.basetypeID, rdcspv::StorageClass::Private)); + io.privatePtrID = + editor.DeclareType(rdcspv::Pointer(io.basetypeID, rdcspv::StorageClass::Private)); RDCASSERT(io.basetypeID && io.vec4ID && io.constID && io.privatePtrID, io.basetypeID, io.vec4ID, io.constID, io.privatePtrID); @@ -487,32 +492,33 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV for(tbufferType tb : {tbuffer_float, tbuffer_sint, tbuffer_uint}) { - SPIRVScalar scalarType = scalar(); + rdcspv::Scalar scalarType = rdcspv::scalar(); const char *name = "float_vbuffers"; if(tb == tbuffer_sint) { - scalarType = scalar(); + scalarType = rdcspv::scalar(); name = "int_vbuffers"; } else if(tb == tbuffer_uint) { - scalarType = scalar(); + scalarType = rdcspv::scalar(); name = "uint_vbuffers"; } tbuffers[tb].imageTypeID = editor.DeclareType( - SPIRVImage(scalarType, rdcspv::Dim::Buffer, 0, 0, 0, 1, rdcspv::ImageFormat::Unknown)); - tbuffers[tb].imageSampledTypeID = editor.DeclareType(SPIRVSampledImage(tbuffers[tb].imageTypeID)); + rdcspv::Image(scalarType, rdcspv::Dim::Buffer, 0, 0, 0, 1, rdcspv::ImageFormat::Unknown)); + tbuffers[tb].imageSampledTypeID = + editor.DeclareType(rdcspv::SampledImage(tbuffers[tb].imageTypeID)); rdcspv::Id arrayType = editor.MakeId(); editor.AddType(rdcspv::OpTypeArray(arrayType, tbuffers[tb].imageSampledTypeID, arraySize)); rdcspv::Id arrayPtrType = - editor.DeclareType(SPIRVPointer(arrayType, rdcspv::StorageClass::UniformConstant)); + editor.DeclareType(rdcspv::Pointer(arrayType, rdcspv::StorageClass::UniformConstant)); tbuffers[tb].pointerTypeID = editor.DeclareType( - SPIRVPointer(tbuffers[tb].imageSampledTypeID, rdcspv::StorageClass::UniformConstant)); + rdcspv::Pointer(tbuffers[tb].imageSampledTypeID, rdcspv::StorageClass::UniformConstant)); tbuffers[tb].variableID = editor.MakeId(); editor.AddVariable(rdcspv::OpVariable(arrayPtrType, tbuffers[tb].variableID, @@ -533,14 +539,14 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV if(draw->flags & DrawFlags::Indexed) { - uint32Vec4ID = editor.DeclareType(SPIRVVector(scalar(), 4)); + uint32Vec4ID = editor.DeclareType(rdcspv::Vector(rdcspv::scalar(), 4)); - idxImageTypeID = editor.DeclareType(SPIRVImage(scalar(), rdcspv::Dim::Buffer, 0, 0, 0, - 1, rdcspv::ImageFormat::Unknown)); - idxSampledTypeID = editor.DeclareType(SPIRVSampledImage(idxImageTypeID)); + idxImageTypeID = editor.DeclareType(rdcspv::Image( + rdcspv::scalar(), rdcspv::Dim::Buffer, 0, 0, 0, 1, rdcspv::ImageFormat::Unknown)); + idxSampledTypeID = editor.DeclareType(rdcspv::SampledImage(idxImageTypeID)); rdcspv::Id idxImagePtrType = - editor.DeclareType(SPIRVPointer(idxSampledTypeID, rdcspv::StorageClass::UniformConstant)); + editor.DeclareType(rdcspv::Pointer(idxSampledTypeID, rdcspv::StorageClass::UniformConstant)); idxImagePtr = editor.MakeId(); editor.AddVariable( @@ -589,7 +595,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV // meshOutput * rdcspv::Id outputStructPtrID = - editor.DeclareType(SPIRVPointer(outputStructID, rdcspv::StorageClass::Uniform)); + editor.DeclareType(rdcspv::Pointer(outputStructID, rdcspv::StorageClass::Uniform)); editor.SetName(outputStructPtrID, "meshOutput_ptr"); // meshOutput *outputData; @@ -650,9 +656,9 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV outBufferVarID, rdcspv::DecorationParam(0))); } - rdcspv::Id uint32Vec3ID = editor.DeclareType(SPIRVVector(scalar(), 3)); + rdcspv::Id uint32Vec3ID = editor.DeclareType(rdcspv::Vector(rdcspv::scalar(), 3)); rdcspv::Id invocationPtr = - editor.DeclareType(SPIRVPointer(uint32Vec3ID, rdcspv::StorageClass::Input)); + editor.DeclareType(rdcspv::Pointer(uint32Vec3ID, rdcspv::StorageClass::Input)); rdcspv::Id invocationId = editor.AddVariable( rdcspv::OpVariable(invocationPtr, editor.MakeId(), rdcspv::StorageClass::Input)); editor.AddDecoration(rdcspv::OpDecorate( @@ -669,7 +675,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV // editor.SetName(wrapperEntry, "RenderDoc_MeshFetch_Wrapper_Entrypoint"); // we remove all entry points and just create one of our own. - rdcspv::Iter it = editor.Begin(SPIRVSection::EntryPoints); + rdcspv::Iter it = editor.Begin(rdcspv::Section::EntryPoints); { // there should already have been at least one entry point @@ -694,12 +700,12 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV ++it; } - for(rdcspv::Iter end = editor.End(SPIRVSection::EntryPoints); it < end; ++it) + for(rdcspv::Iter end = editor.End(rdcspv::Section::EntryPoints); it < end; ++it) editor.Remove(it); // Strip away any execution modes from the original shaders - for(it = editor.Begin(SPIRVSection::ExecutionMode); it < editor.End(SPIRVSection::ExecutionMode); - ++it) + for(it = editor.Begin(rdcspv::Section::ExecutionMode); + it < editor.End(rdcspv::Section::ExecutionMode); ++it) { if(it.opcode() == rdcspv::Op::ExecutionMode) { @@ -727,14 +733,14 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV wrapperEntry, rdcspv::ExecutionModeParam(MeshOutputDispatchWidth, 1, 1))); - rdcspv::Id uint32ID = editor.DeclareType(scalar()); + rdcspv::Id uint32ID = editor.DeclareType(rdcspv::scalar()); // add the wrapper function { std::vector ops; - rdcspv::Id voidType = editor.DeclareType(scalar()); - rdcspv::Id funcType = editor.DeclareType(SPIRVFunction(voidType, {})); + rdcspv::Id voidType = editor.DeclareType(rdcspv::scalar()); + rdcspv::Id funcType = editor.DeclareType(rdcspv::Function(voidType, {})); ops.push_back(rdcspv::OpFunction(voidType, wrapperEntry, rdcspv::FunctionControl::None, funcType)); @@ -771,8 +777,8 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV // bool inBounds = viewID < numViews; rdcspv::Id inBounds = editor.MakeId(); - ops.push_back(rdcspv::OpULessThan(editor.DeclareType(scalar()), inBounds, viewID, - numViewsConstID)); + ops.push_back(rdcspv::OpULessThan(editor.DeclareType(rdcspv::scalar()), inBounds, + viewID, numViewsConstID)); // if(inBounds) goto continueLabel; else goto killLabel; rdcspv::Id killLabel = editor.MakeId(); @@ -981,7 +987,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV rdcspv::Id glsl450 = editor.ImportExtInst("GLSL.std.450"); - rdcspv::Id uvec2Type = editor.DeclareType(SPIRVVector(scalar(), 2)); + rdcspv::Id uvec2Type = editor.DeclareType(rdcspv::Vector(rdcspv::scalar(), 2)); rdcspv::Id comps[4] = {}; for(uint32_t c = 0; c < refl.inputSignature[i].compCount; c++) @@ -1002,7 +1008,7 @@ static void ConvertToMeshOutputCompute(const ShaderReflection &refl, const SPIRV ops.push_back(rdcspv::Operation( rdcspv::Op::ExtInst, { - editor.DeclareType(scalar()).value(), comps[c].value(), + editor.DeclareType(rdcspv::scalar()).value(), comps[c].value(), glsl450.value(), (uint32_t)rdcspv::GLSLstd450::PackDouble2x32, packed.value(), })); } diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 0798360bb..5d5e54f61 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -3760,16 +3760,16 @@ void VulkanReplay::BuildTargetShader(ShaderEncoding sourceEncoding, bytebuf sour if(sourceEncoding == ShaderEncoding::GLSL) { - SPIRVShaderStage stage = SPIRVShaderStage::Invalid; + rdcspv::ShaderStage stage = rdcspv::ShaderStage::Invalid; switch(type) { - case ShaderStage::Vertex: stage = SPIRVShaderStage::Vertex; break; - case ShaderStage::Hull: stage = SPIRVShaderStage::TessControl; break; - case ShaderStage::Domain: stage = SPIRVShaderStage::TessEvaluation; break; - case ShaderStage::Geometry: stage = SPIRVShaderStage::Geometry; break; - case ShaderStage::Pixel: stage = SPIRVShaderStage::Fragment; break; - case ShaderStage::Compute: stage = SPIRVShaderStage::Compute; break; + case ShaderStage::Vertex: stage = rdcspv::ShaderStage::Vertex; break; + case ShaderStage::Hull: stage = rdcspv::ShaderStage::TessControl; break; + case ShaderStage::Domain: stage = rdcspv::ShaderStage::TessEvaluation; break; + case ShaderStage::Geometry: stage = rdcspv::ShaderStage::Geometry; break; + case ShaderStage::Pixel: stage = rdcspv::ShaderStage::Fragment; break; + case ShaderStage::Compute: stage = rdcspv::ShaderStage::Compute; break; default: RDCERR("Unexpected type in BuildShader!"); *id = ResourceId(); @@ -3779,9 +3779,9 @@ void VulkanReplay::BuildTargetShader(ShaderEncoding sourceEncoding, bytebuf sour std::vector sources; sources.push_back(std::string((char *)source.begin(), (char *)source.end())); - SPIRVCompilationSettings settings(SPIRVSourceLanguage::VulkanGLSL, stage); + rdcspv::CompilationSettings settings(rdcspv::InputLanguage::VulkanGLSL, stage); - std::string output = CompileSPIRV(settings, sources, spirv); + std::string output = rdcspv::Compile(settings, sources, spirv); if(spirv.empty()) { diff --git a/renderdoc/driver/vulkan/vk_shader_cache.cpp b/renderdoc/driver/vulkan/vk_shader_cache.cpp index 9fec3879f..e6f4e1bc2 100644 --- a/renderdoc/driver/vulkan/vk_shader_cache.cpp +++ b/renderdoc/driver/vulkan/vk_shader_cache.cpp @@ -41,48 +41,48 @@ struct BuiltinShaderConfig { BuiltinShader builtin; EmbeddedResourceType resource; - SPIRVShaderStage stage; + rdcspv::ShaderStage stage; FeatureCheck checks; bool uniforms; }; static const BuiltinShaderConfig builtinShaders[] = { - {BuiltinShader::BlitVS, EmbeddedResource(glsl_blit_vert), SPIRVShaderStage::Vertex, + {BuiltinShader::BlitVS, EmbeddedResource(glsl_blit_vert), rdcspv::ShaderStage::Vertex, FeatureCheck::NoCheck, true}, {BuiltinShader::CheckerboardFS, EmbeddedResource(glsl_checkerboard_frag), - SPIRVShaderStage::Fragment, FeatureCheck::NoCheck, true}, + rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true}, {BuiltinShader::TexDisplayFS, EmbeddedResource(glsl_texdisplay_frag), - SPIRVShaderStage::Fragment, FeatureCheck::NoCheck, true}, - {BuiltinShader::FixedColFS, EmbeddedResource(glsl_fixedcol_frag), SPIRVShaderStage::Fragment, + rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true}, + {BuiltinShader::FixedColFS, EmbeddedResource(glsl_fixedcol_frag), rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, false}, - {BuiltinShader::TextVS, EmbeddedResource(glsl_vktext_vert), SPIRVShaderStage::Vertex, + {BuiltinShader::TextVS, EmbeddedResource(glsl_vktext_vert), rdcspv::ShaderStage::Vertex, FeatureCheck::NoCheck, true}, - {BuiltinShader::TextFS, EmbeddedResource(glsl_vktext_frag), SPIRVShaderStage::Fragment, + {BuiltinShader::TextFS, EmbeddedResource(glsl_vktext_frag), rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true}, - {BuiltinShader::MeshVS, EmbeddedResource(glsl_mesh_vert), SPIRVShaderStage::Vertex, + {BuiltinShader::MeshVS, EmbeddedResource(glsl_mesh_vert), rdcspv::ShaderStage::Vertex, FeatureCheck::NoCheck, true}, - {BuiltinShader::MeshGS, EmbeddedResource(glsl_mesh_geom), SPIRVShaderStage::Geometry, + {BuiltinShader::MeshGS, EmbeddedResource(glsl_mesh_geom), rdcspv::ShaderStage::Geometry, FeatureCheck::NoCheck, true}, - {BuiltinShader::MeshFS, EmbeddedResource(glsl_mesh_frag), SPIRVShaderStage::Fragment, + {BuiltinShader::MeshFS, EmbeddedResource(glsl_mesh_frag), rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true}, - {BuiltinShader::MeshCS, EmbeddedResource(glsl_mesh_comp), SPIRVShaderStage::Compute, + {BuiltinShader::MeshCS, EmbeddedResource(glsl_mesh_comp), rdcspv::ShaderStage::Compute, FeatureCheck::NoCheck, true}, {BuiltinShader::QuadResolveFS, EmbeddedResource(glsl_quadresolve_frag), - SPIRVShaderStage::Fragment, FeatureCheck::FragmentStores, true}, - {BuiltinShader::QuadWriteFS, EmbeddedResource(glsl_quadwrite_frag), SPIRVShaderStage::Fragment, + rdcspv::ShaderStage::Fragment, FeatureCheck::FragmentStores, true}, + {BuiltinShader::QuadWriteFS, EmbeddedResource(glsl_quadwrite_frag), rdcspv::ShaderStage::Fragment, FeatureCheck::FragmentStores | FeatureCheck::NonMetalBackend, false}, - {BuiltinShader::TrisizeGS, EmbeddedResource(glsl_trisize_geom), SPIRVShaderStage::Geometry, + {BuiltinShader::TrisizeGS, EmbeddedResource(glsl_trisize_geom), rdcspv::ShaderStage::Geometry, FeatureCheck::NoCheck, true}, - {BuiltinShader::TrisizeFS, EmbeddedResource(glsl_trisize_frag), SPIRVShaderStage::Fragment, + {BuiltinShader::TrisizeFS, EmbeddedResource(glsl_trisize_frag), rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true}, - {BuiltinShader::MS2ArrayCS, EmbeddedResource(glsl_ms2array_comp), SPIRVShaderStage::Compute, + {BuiltinShader::MS2ArrayCS, EmbeddedResource(glsl_ms2array_comp), rdcspv::ShaderStage::Compute, FeatureCheck::ShaderMSAAStorage | FeatureCheck::NonMetalBackend, true}, - {BuiltinShader::Array2MSCS, EmbeddedResource(glsl_array2ms_comp), SPIRVShaderStage::Compute, + {BuiltinShader::Array2MSCS, EmbeddedResource(glsl_array2ms_comp), rdcspv::ShaderStage::Compute, FeatureCheck::ShaderMSAAStorage | FeatureCheck::NonMetalBackend, true}, {BuiltinShader::DepthMS2ArrayFS, EmbeddedResource(glsl_depthms2arr_frag), - SPIRVShaderStage::Fragment, FeatureCheck::NonMetalBackend, true}, + rdcspv::ShaderStage::Fragment, FeatureCheck::NonMetalBackend, true}, {BuiltinShader::DepthArray2MSFS, EmbeddedResource(glsl_deptharr2ms_frag), - SPIRVShaderStage::Fragment, FeatureCheck::NonMetalBackend, true}, + rdcspv::ShaderStage::Fragment, FeatureCheck::NonMetalBackend, true}, }; RDCCOMPILE_ASSERT(ARRAY_COUNT(builtinShaders) == arraydim(), @@ -134,8 +134,8 @@ VulkanShaderCache::VulkanShaderCache(WrappedVulkan *driver) m_GlobalDefines += "#define METAL_BACKEND\n"; std::string src; - SPIRVCompilationSettings compileSettings; - compileSettings.lang = SPIRVSourceLanguage::VulkanGLSL; + rdcspv::CompilationSettings compileSettings; + compileSettings.lang = rdcspv::InputLanguage::VulkanGLSL; for(auto i : indices()) { @@ -166,7 +166,7 @@ VulkanShaderCache::VulkanShaderCache(WrappedVulkan *driver) continue; } - if(config.stage == SPIRVShaderStage::Geometry && !features.geometryShader) + if(config.stage == rdcspv::ShaderStage::Geometry && !features.geometryShader) continue; src = GenerateGLSLShader(GetDynamicEmbeddedResource(config.resource), eShaderVulkan, 430, @@ -217,7 +217,7 @@ VulkanShaderCache::~VulkanShaderCache() m_pDriver->vkDestroyShaderModule(m_Device, m_BuiltinShaderModules[i], NULL); } -std::string VulkanShaderCache::GetSPIRVBlob(const SPIRVCompilationSettings &settings, +std::string VulkanShaderCache::GetSPIRVBlob(const rdcspv::CompilationSettings &settings, const std::string &src, SPIRVBlob &outBlob) { RDCASSERT(!src.empty()); @@ -236,7 +236,7 @@ std::string VulkanShaderCache::GetSPIRVBlob(const SPIRVCompilationSettings &sett } SPIRVBlob spirv = new std::vector(); - std::string errors = CompileSPIRV(settings, {src}, *spirv); + std::string errors = rdcspv::Compile(settings, {src}, *spirv); if(!errors.empty()) { diff --git a/renderdoc/driver/vulkan/vk_shader_cache.h b/renderdoc/driver/vulkan/vk_shader_cache.h index aa7a77735..9b5a0a373 100644 --- a/renderdoc/driver/vulkan/vk_shader_cache.h +++ b/renderdoc/driver/vulkan/vk_shader_cache.h @@ -63,7 +63,7 @@ public: VulkanShaderCache(WrappedVulkan *driver); ~VulkanShaderCache(); - std::string GetSPIRVBlob(const SPIRVCompilationSettings &settings, const std::string &src, + std::string GetSPIRVBlob(const rdcspv::CompilationSettings &settings, const std::string &src, SPIRVBlob &outBlob); SPIRVBlob GetBuiltinBlob(BuiltinShader builtin) { return m_BuiltinShaderBlobs[(size_t)builtin]; }