Fixed review comments

Also added new interface to retrieve disassembled spirv

Author: mkeshavaNV

source/compiler-core/slang-downstream-compiler.h

@@ -340,6 +340,10 @@ class IDownstreamCompiler : public ICastable
     /// Disassemble and print to stdout
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     disassemble(const uint32_t* contents, int contentsSize) = 0;
+    
+    /// Disassemble and return the result as a string
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    disassembleWithResult(const uint32_t* contents, int contentsSize, String& outString) = 0;
 
     /// True if underlying compiler uses file system to communicate source
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() = 0;
@@ -384,6 +388,17 @@ class DownstreamCompilerBase : public ComBaseObject, public IDownstreamCompiler
         SLANG_UNUSED(contentsSize);
         return SLANG_FAIL;
     }
+    
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    disassembleWithResult(const uint32_t* contents, int contentsSize, String& outString) SLANG_OVERRIDE
+    {
+        SLANG_UNUSED(contents);
+        SLANG_UNUSED(contentsSize);
+        SLANG_UNUSED(outString);
+        return SLANG_FAIL;
+    }
+
+    virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() SLANG_OVERRIDE { return true; }
 
     DownstreamCompilerBase(const Desc& desc)
         : m_desc(desc)

source/compiler-core/slang-glslang-compiler.cpp

@@ -49,6 +49,8 @@ class GlslangDownstreamCompiler : public DownstreamCompilerBase
     validate(const uint32_t* contents, int contentsSize) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     disassemble(const uint32_t* contents, int contentsSize) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    disassembleWithResult(const uint32_t* contents, int contentsSize, String& outString) SLANG_OVERRIDE;
 
     /// Must be called before use
     SlangResult init(ISlangSharedLibrary* library);
@@ -66,6 +68,7 @@ class GlslangDownstreamCompiler : public DownstreamCompilerBase
     glslang_CompileFunc_1_2 m_compile_1_2 = nullptr;
     glslang_ValidateSPIRVFunc m_validate = nullptr;
     glslang_DisassembleSPIRVFunc m_disassemble = nullptr;
+    glslang_DisassembleSPIRVWithResultFunc m_disassembleWithResult = nullptr;
 
     ComPtr<ISlangSharedLibrary> m_sharedLibrary;
 
@@ -80,6 +83,8 @@ SlangResult GlslangDownstreamCompiler::init(ISlangSharedLibrary* library)
     m_validate = (glslang_ValidateSPIRVFunc)library->findFuncByName("glslang_validateSPIRV");
     m_disassemble =
         (glslang_DisassembleSPIRVFunc)library->findFuncByName("glslang_disassembleSPIRV");
+    m_disassembleWithResult =
+        (glslang_DisassembleSPIRVWithResultFunc)library->findFuncByName("glslang_disassembleSPIRVWithResult");
 
     if (m_compile_1_0 == nullptr && m_compile_1_1 == nullptr && m_compile_1_2 == nullptr)
     {
@@ -323,6 +328,25 @@ SlangResult GlslangDownstreamCompiler::disassemble(const uint32_t* contents, int
     return SLANG_FAIL;
 }
 
+SlangResult GlslangDownstreamCompiler::disassembleWithResult(const uint32_t* contents, int contentsSize, String& outString)
+{
+    if (m_disassembleWithResult == nullptr)
+    {
+        return SLANG_FAIL;
+    }
+
+    char* resultString = nullptr;
+    if (m_disassembleWithResult(contents, contentsSize, &resultString))
+    {
+        if (resultString)
+        {
+            outString = String(resultString);
+            return SLANG_OK;
+        }
+    }
+    return SLANG_FAIL;
+}
+
 bool GlslangDownstreamCompiler::canConvert(const ArtifactDesc& from, const ArtifactDesc& to)
 {
     // Can only disassemble blobs that are SPIR-V

source/slang-glslang/slang-glslang.cpp

@@ -184,36 +184,69 @@ extern "C"
     return tools.Validate(contents, contentsSize, options);
 }
 
-// Disassemble the given SPIRV-ASM instructions.
+// Forward declaration for the disassembly function
+extern "C"
+#ifdef _MSC_VER
+    _declspec(dllexport)
+#else
+    __attribute__((__visibility__("default")))
+#endif
+    bool glslang_disassembleSPIRVWithResult(const uint32_t* contents, int contentsSize, char** outString);
+
+// Disassemble the given SPIRV-ASM instructions
 extern "C"
 #ifdef _MSC_VER
     _declspec(dllexport)
 #else
     __attribute__((__visibility__("default")))
 #endif
         bool glslang_disassembleSPIRV(const uint32_t* contents, int contentsSize)
+{    
+    return glslang_disassembleSPIRVWithResult(contents, contentsSize, nullptr);
+}
+
+// Disassemble the given SPIRV-ASM instructions and return the result as a string.
+extern "C"
+#ifdef _MSC_VER
+    _declspec(dllexport)
+#else
+    __attribute__((__visibility__("default")))
+#endif
+        bool glslang_disassembleSPIRVWithResult(const uint32_t* contents, int contentsSize, char** outString)
 {
     static const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_5;
+    spv_text text;
 
     uint32_t options = SPV_BINARY_TO_TEXT_OPTION_NONE;
     options |= SPV_BINARY_TO_TEXT_OPTION_COMMENT;
-    options |= SPV_BINARY_TO_TEXT_OPTION_PRINT;
-    options |= SPV_BINARY_TO_TEXT_OPTION_COLOR;
     options |= SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES;
+    options |= SPV_BINARY_TO_TEXT_OPTION_INDENT;
 
     spv_diagnostic diagnostic = nullptr;
     spv_context context = spvContextCreate(kDefaultEnvironment);
     spv_result_t error =
-        spvBinaryToText(context, contents, contentsSize, options, nullptr, &diagnostic);
+        spvBinaryToText(context, contents, contentsSize, options, &text, &diagnostic);
     spvContextDestroy(context);
     if (error)
     {
         spvDiagnosticPrint(diagnostic);
         spvDiagnosticDestroy(diagnostic);
         return false;
     }
+    else
+    {
+        if (outString)
+        {
+            // Allocate memory for the output string and copy the result
+            size_t len = text->length + 1;  // +1 for null terminator
+            *outString = new char[len];
+            memcpy(*outString, text->str, text->length);
+            (*outString)[text->length] = '\0';  // Ensure null termination
+        }
 
-    return true;
+        spvTextDestroy(text);
+        return true;
+    }
 }
 
 // Apply the SPIRV-Tools optimizer to generated SPIR-V based on the desired optimization level

source/slang-glslang/slang-glslang.h

@@ -166,5 +166,6 @@ typedef int (*glslang_CompileFunc_1_1)(glslang_CompileRequest_1_1* request);
 typedef int (*glslang_CompileFunc_1_2)(glslang_CompileRequest_1_2* request);
 typedef bool (*glslang_ValidateSPIRVFunc)(const uint32_t* contents, int contentsSize);
 typedef bool (*glslang_DisassembleSPIRVFunc)(const uint32_t* contents, int contentsSize);
+typedef bool (*glslang_DisassembleSPIRVWithResultFunc)(const uint32_t* contents, int contentsSize, char** outString);
 typedef bool (*glslang_LinkSPIRVFunc)(glslang_LinkRequest* request);
 #endif

source/slang/CMakeLists.txt

@@ -230,7 +230,6 @@ set(slang_link_args
     slang-reflect-headers
     slang-lookup-tables
     SPIRV-Headers
-    SPIRV-Tools
 )
 set(slang_interface_args INCLUDE_DIRECTORIES_PUBLIC ${slang_SOURCE_DIR}/include)
 set(slang_public_lib_args

source/slang/slang-compiler-tu.cpp

@@ -10,23 +10,6 @@
 
 namespace Slang
 {
-static void dumpIRIfEnabled(
-    CodeGenContext* codeGenContext,
-    IRModule* irModule,
-    char const* label = nullptr)
-{
-    if (codeGenContext->shouldDumpIR())
-    {
-        DiagnosticSinkWriter writer(codeGenContext->getSink());
-        dumpIR(
-            irModule,
-            codeGenContext->getIRDumpOptions(),
-            label,
-            codeGenContext->getSourceManager(),
-            &writer);
-    }
-}
-
 // Only attempt to precompile functions:
 // 1) With function bodies (not just empty decls)
 // 2) Not marked with unsafeForceInlineDecoration
@@ -120,10 +103,6 @@ Module::precompileForTarget(SlangCompileTarget target, slang::IBlob** outDiagnos
     applySettingsToDiagnosticSink(&sink, &sink, linkage->m_optionSet);
     applySettingsToDiagnosticSink(&sink, &sink, m_optionSet);
 
-    // Configure diagnostic writer to write directly to stderr
-    static FileWriter stdError(stderr, WriterFlag::IsStatic | WriterFlag::IsUnowned);
-    sink.writer = &stdError;
-
     RefPtr<TargetRequest> targetReq = new TargetRequest(linkage, targetEnum);
 
     List<RefPtr<ComponentType>> allComponentTypes;
@@ -164,9 +143,6 @@ Module::precompileForTarget(SlangCompileTarget target, slang::IBlob** outDiagnos
     CodeGenContext::Shared sharedCodeGenContext(&tp, entryPointIndices, &sink, nullptr);
     CodeGenContext codeGenContext(&sharedCodeGenContext);
 
-    // Dump initial IR before precompilation
-    dumpIRIfEnabled(&codeGenContext, module, "PRECOMPILE_FOR_TARGET");
-
     // Mark all public functions as exported, ensure there's at least one. Store a mapping
     // of function name to IRInst* for later reference. After linking is done, we'll scan
     // the linked result to see which functions survived the pruning and are included in the
@@ -205,9 +181,6 @@ Module::precompileForTarget(SlangCompileTarget target, slang::IBlob** outDiagnos
         return SLANG_E_NOT_AVAILABLE;
     }
 
-    // Dump IR after precompilation but before applying decorations
-    dumpIRIfEnabled(&codeGenContext, module, "PRECOMPILE_FOR_TARGET_BEFORE_DECORATIONS");
-
     for (const auto& mangledName : metadata->getExportedFunctionMangledNames())
     {
         auto moduleInst = nameToFunction[mangledName];
@@ -239,9 +212,6 @@ Module::precompileForTarget(SlangCompileTarget target, slang::IBlob** outDiagnos
     builder.setInsertInto(module);
 
     builder.emitEmbeddedDownstreamIR(targetReq->getTarget(), blob);
-
-    // Dump final IR after all transformations
-    dumpIRIfEnabled(&codeGenContext, module, "PRECOMPILE_FOR_TARGET_COMPLETE_ALL");
     return SLANG_OK;
 }
 

source/slang/slang-ir.cpp

@@ -8,8 +8,6 @@
 #include "slang-ir-util.h"
 #include "slang-mangle.h"
 
-#include "spirv-tools/libspirv.h"
-
 namespace Slang
 {
 struct IRSpecContext;
@@ -7167,37 +7165,33 @@ static void dumpInstExpr(IRDumpContext* context, IRInst* inst)
             const uint32_t* spirvCode = (const uint32_t*)blob.begin();
             const size_t spirvWordCount = blob.getLength() / sizeof(uint32_t);
 
-            // Create SPIR-V tools context
-            spv_context spvContext = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
-            spv_text text = nullptr;
-            spv_diagnostic diagnostic = nullptr;
-
-            // Disassemble with friendly names and comments
-            spv_result_t result = spvBinaryToText(
-                spvContext,
-                spirvCode,
-                spirvWordCount,
-                SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | SPV_BINARY_TO_TEXT_OPTION_INDENT,
-                &text,
-                &diagnostic);
-
-            if (result == SPV_SUCCESS && text)
+            // Get the compiler from the session through the module
+            auto module = inst->getModule();
+            auto session = module->getSession();
+            IDownstreamCompiler* compiler = session->getOrLoadDownstreamCompiler(
+                PassThroughMode::SpirvDis,
+                nullptr);
+
+            if (compiler)
             {
-                dump(context, "\n");
-                dumpIndent(context);
-                dump(context, text->str);
+                // Use glslang interface to disassemble with string output
+                String disassemblyOutput;
+                if (SLANG_SUCCEEDED(compiler->disassembleWithResult(spirvCode, int(spirvWordCount), disassemblyOutput)))
+                {
+                    // Dump the captured disassembly
+                    dump(context, "\n");
+                    dumpIndent(context);
+                    dump(context, disassemblyOutput);
+                }
+                else
+                {
+                    dump(context, "<disassembly failed>");
+                }
             }
             else
             {
                 dump(context, "<invalid SPIR-V>");
             }
-
-            // Cleanup
-            if (diagnostic)
-                spvDiagnosticDestroy(diagnostic);
-            if (text)
-                spvTextDestroy(text);
-            spvContextDestroy(spvContext);
         }
         else
         {

source/slang/slang.cpp

@@ -3746,6 +3746,18 @@ SlangResult EndToEndCompileRequest::executeActionsInner()
             {
                 SLANG_RETURN_ON_FAIL(
                     translationUnit->getModule()->precompileForTarget(targetEnum, nullptr));
+
+                if (frontEndReq->optionSet.shouldDumpIR())
+                {
+                    DiagnosticSinkWriter writer(frontEndReq->getSink());
+
+                    dumpIR(
+                        translationUnit->getModule()->getIRModule(),
+                        frontEndReq->m_irDumpOptions,
+                        "PRECOMPILE_FOR_TARGET_COMPLETE_ALL",
+                        frontEndReq->getSourceManager(),
+                        &writer);
+                }
             }
         }
     }