Merge branch 'master' into feature/make-witness-table-hoistable

Author: jkwak-work

.github/workflows/dockerfiles/ubuntu-18.04-x64/Dockerfile

@@ -12,6 +12,8 @@
 *.zip
 *.ini
 *.DS_store
+.direnv
+.envrc
 .gdb_history
 .vimspector
 .vimspector.json

.gitignore

@@ -311,6 +311,20 @@ cmake --preset vs2022 --fresh -A arm64 -DSLANG_GENERATORS_PATH=generators/bin
 cmake --build --preset release
 ```
 
+### Nix
+
+This repository contains a [Nix](https://nixos.org/)
+[flake](https://wiki.nixos.org/wiki/Flakes) (not officially supported or
+tested), which provides the necessary prerequisites for local development. Also,
+if you use [direnv](https://direnv.net/), you can run the following commands to
+have the Nix environment automatically activate when you enter your clone of
+this repository:
+
+```bash
+echo 'use flake' >> .envrc
+direnv allow
+```
+
 ## Building with an older CMake
 
 Because older CMake versions don't support all the features we want to use in

docs/building.md

@@ -0,0 +1,33 @@
+{
+  description = "The Slang Shading Language and Compiler";
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+      in
+      {
+        devShell =
+          with pkgs;
+          mkShell {
+            buildInputs = [
+              cmake
+              llvm
+              ninja
+              nixfmt-rfc-style
+              python3
+              xorg.libX11
+            ];
+          };
+      }
+    );
+}

flake.lock

@@ -681,6 +681,8 @@ extern "C"
     SLANG_API size_t spReflectionVariableLayout_GetSpace(
         SlangReflectionVariableLayout* var,
         SlangParameterCategory category);
+    SLANG_API SlangImageFormat
+    spReflectionVariableLayout_GetImageFormat(SlangReflectionVariableLayout* var);
 
     SLANG_API char const* spReflectionVariableLayout_GetSemanticName(
         SlangReflectionVariableLayout* var);

flake.nix

@@ -1015,6 +1015,7 @@ typedef uint32_t SlangSizeT;
         SaveGLSLModuleBinSource,
 
         SkipDownstreamLinking, // bool, experimental
+        DumpModule,
         CountOf,
     };
 
@@ -2921,6 +2922,11 @@ struct VariableLayoutReflection
             (SlangParameterCategory)category);
     }
 
+    SlangImageFormat getImageFormat()
+    {
+        return spReflectionVariableLayout_GetImageFormat((SlangReflectionVariableLayout*)this);
+    }
+
     char const* getSemanticName()
     {
         return spReflectionVariableLayout_GetSemanticName((SlangReflectionVariableLayout*)this);
@@ -4417,6 +4423,11 @@ struct IModule : public IComponentType
     virtual SLANG_NO_THROW char const* SLANG_MCALL getDependencyFilePath(SlangInt32 index) = 0;
 
     virtual SLANG_NO_THROW DeclReflection* SLANG_MCALL getModuleReflection() = 0;
+
+    /** Disassemble a module.
+     */
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    disassemble(slang::IBlob** outDisassembledBlob) = 0;
 };
 
     #define SLANG_UUID_IModule IModule::getTypeGuid()

include/slang-deprecated.h

@@ -244,4 +244,12 @@ IEntryPointRecorder* ModuleRecorder::getEntryPointRecorder(slang::IEntryPoint* e
         return result.detach();
     }
 }
+
+SlangResult ModuleRecorder::disassemble(ISlangBlob** outBlob)
+{
+    // No need to record this call as it is just a query.
+    slangRecordLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__);
+    auto res = m_actualModule->disassemble(outBlob);
+    return res;
+}
 } // namespace SlangRecord

include/slang.h

@@ -56,6 +56,8 @@ class ModuleRecorder : public IModuleRecorder, public IComponentTypeRecorder
         ISlangBlob** outDiagnostics) override;
     virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDependencyFileCount() override;
     virtual SLANG_NO_THROW char const* SLANG_MCALL getDependencyFilePath(SlangInt32 index) override;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    disassemble(slang::IBlob** outDisassembly) override;
 
     // Interfaces for `IComponentType`
     virtual SLANG_NO_THROW slang::ISession* SLANG_MCALL getSession() override

source/slang-record-replay/record/slang-module.cpp

@@ -1832,6 +1832,18 @@ class Module : public ComponentType, public slang::IModule
 
     // Source files that have been pulled into the module with `__include`.
     Dictionary<SourceFile*, FileDecl*> m_mapSourceFileToFileDecl;
+
+public:
+    SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(slang::IBlob** outDisassembledBlob) override
+    {
+        if (!outDisassembledBlob)
+            return SLANG_E_INVALID_ARG;
+        String disassembly;
+        this->getIRModule()->getModuleInst()->dump(disassembly);
+        auto blob = StringUtil::createStringBlob(disassembly);
+        *outDisassembledBlob = blob.detach();
+        return SLANG_OK;
+    }
 };
 typedef Module LoadedModule;
 

source/slang-record-replay/record/slang-module.h

@@ -9001,24 +9001,33 @@ void IRInst::addBlock(IRBlock* block)
     block->insertAtEnd(this);
 }
 
-void IRInst::dump()
+void IRInst::dump(String& outStr)
 {
+    StringBuilder sb;
+
     if (auto intLit = as<IRIntLit>(this))
     {
-        std::cout << intLit->getValue() << std::endl;
+        sb << intLit->getValue();
     }
     else if (auto stringLit = as<IRStringLit>(this))
     {
-        std::cout << stringLit->getStringSlice().begin() << std::endl;
+        sb << stringLit->getStringSlice();
     }
     else
     {
-        StringBuilder sb;
         IRDumpOptions options;
         StringWriter writer(&sb, Slang::WriterFlag::AutoFlush);
         dumpIR(this, options, nullptr, &writer);
-        std::cout << sb.toString().begin() << std::endl;
     }
+
+    outStr = sb.toString();
+}
+
+void IRInst::dump()
+{
+    String s;
+    dump(s);
+    std::cout << s.begin() << std::endl;
 }
 } // namespace Slang
 

source/slang/slang-compiler.h

@@ -814,10 +814,14 @@ struct IRInst
     ///
     void _insertAt(IRInst* inPrev, IRInst* inNext, IRInst* inParent);
 
-    /// Print the IR to stdout for debugging purposes
+    /// Print the IR to stdout for debugging purposes.
     ///
     void dump();
 
+    /// Print the IR to a string for debugging purposes.
+    ///
+    void dump(String& outStr);
+
     /// Insert a basic block at the end of this func/code containing inst.
     void addBlock(IRBlock* block);
 

source/slang/slang-ir.cpp

@@ -802,7 +802,8 @@ void initCommandOptions(CommandOptions& options)
         {OptionKind::VerifyDebugSerialIr,
          "-verify-debug-serial-ir",
          nullptr,
-         "Verify IR in the front-end."}};
+         "Verify IR in the front-end."},
+        {OptionKind::DumpModule, "-dump-module", nullptr, "Disassemble and print the module IR."}};
     _addOptions(makeConstArrayView(debuggingOpts), options);
 
     /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Experimental !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
@@ -2947,6 +2948,88 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv)
                 Int index = 0;
                 SLANG_RETURN_ON_FAIL(_expectInt(arg, index));
                 linkage->m_optionSet.add(OptionKind::BindlessSpaceIndex, (int)index);
+                break;
+            }
+        case OptionKind::DumpModule:
+            {
+                CommandLineArg fileName;
+                SLANG_RETURN_ON_FAIL(m_reader.expectArg(fileName));
+                auto desc = slang::SessionDesc();
+                ComPtr<slang::ISession> session;
+                m_session->createSession(desc, session.writeRef());
+                ComPtr<slang::IBlob> diagnostics;
+
+                // Coerce Slang to load from the given file, without letting it automatically
+                // choose .slang-module files over .slang files.
+                // First try to load as source string, and fall back to loading as an IR Blob.
+                // Avoid guessing based on filename or inspecting the file contents.
+                FileStream file;
+                if (SLANG_FAILED(file.init(
+                        fileName.value,
+                        FileMode::Open,
+                        FileAccess::Read,
+                        FileShare::None)))
+                {
+                    m_sink->diagnose(arg.loc, Diagnostics::cannotOpenFile, fileName.value);
+                    return SLANG_FAIL;
+                }
+
+                List<uint8_t> buffer;
+                file.seek(SeekOrigin::End, 0);
+                const Int64 size = file.getPosition();
+                buffer.setCount(size + 1);
+                file.seek(SeekOrigin::Start, 0);
+                SLANG_RETURN_ON_FAIL(file.readExactly(buffer.getBuffer(), (size_t)size));
+                buffer[size] = 0;
+                file.close();
+
+                ComPtr<slang::IModule> module;
+                module = session->loadModuleFromSourceString(
+                    "module",
+                    "path",
+                    (const char*)buffer.getBuffer(),
+                    diagnostics.writeRef());
+                if (!module)
+                {
+                    // Load buffer as an IR blob
+                    ComPtr<slang::IBlob> blob;
+                    blob = RawBlob::create(buffer.getBuffer(), size);
+
+                    module = session->loadModuleFromIRBlob(
+                        "module",
+                        "path",
+                        blob,
+                        diagnostics.writeRef());
+                }
+
+                if (module)
+                {
+                    ComPtr<slang::IBlob> disassemblyBlob;
+                    if (SLANG_FAILED(module->disassemble(disassemblyBlob.writeRef())))
+                    {
+                        m_sink->diagnose(arg.loc, Diagnostics::cannotDisassemble, fileName.value);
+                        return SLANG_FAIL;
+                    }
+                    else
+                    {
+                        // success, print out the disassembly in a way that slang-test can read
+                        m_sink->diagnoseRaw(
+                            Severity::Note,
+                            (const char*)disassemblyBlob->getBufferPointer());
+                    }
+                }
+                else
+                {
+                    if (diagnostics)
+                    {
+                        m_sink->diagnoseRaw(
+                            Severity::Error,
+                            (const char*)diagnostics->getBufferPointer());
+                    }
+                    return SLANG_FAIL;
+                }
+
+
                 break;
             }
         default: