diff --git a/include/slang.h b/include/slang.h index 0507d80999..27fa959863 100644 --- a/include/slang.h +++ b/include/slang.h @@ -1015,6 +1015,7 @@ typedef uint32_t SlangSizeT; SaveGLSLModuleBinSource, SkipDownstreamLinking, // bool, experimental + DumpModule, CountOf, }; @@ -4422,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() diff --git a/source/slang-record-replay/record/slang-module.cpp b/source/slang-record-replay/record/slang-module.cpp index 2071a84917..628a29c90e 100644 --- a/source/slang-record-replay/record/slang-module.cpp +++ b/source/slang-record-replay/record/slang-module.cpp @@ -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 diff --git a/source/slang-record-replay/record/slang-module.h b/source/slang-record-replay/record/slang-module.h index 7608ac52d6..d9c83576db 100644 --- a/source/slang-record-replay/record/slang-module.h +++ b/source/slang-record-replay/record/slang-module.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 diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index cfcbe816f3..d4e05bc48e 100644 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -1832,6 +1832,18 @@ class Module : public ComponentType, public slang::IModule // Source files that have been pulled into the module with `__include`. Dictionary 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; diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp index 92e51fe3b9..6d1d76afce 100644 --- a/source/slang/slang-ir.cpp +++ b/source/slang/slang-ir.cpp @@ -8950,24 +8950,33 @@ void IRInst::addBlock(IRBlock* block) block->insertAtEnd(this); } -void IRInst::dump() +void IRInst::dump(String& outStr) { + StringBuilder sb; + if (auto intLit = as(this)) { - std::cout << intLit->getValue() << std::endl; + sb << intLit->getValue(); } else if (auto stringLit = as(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 diff --git a/source/slang/slang-ir.h b/source/slang/slang-ir.h index aa74c07044..64125be9a2 100644 --- a/source/slang/slang-ir.h +++ b/source/slang/slang-ir.h @@ -813,10 +813,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); diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index 977cf322cc..ed7775e847 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.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 session; + m_session->createSession(desc, session.writeRef()); + ComPtr 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 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 module; + module = session->loadModuleFromSourceString( + "module", + "path", + (const char*)buffer.getBuffer(), + diagnostics.writeRef()); + if (!module) + { + // Load buffer as an IR blob + ComPtr blob; + blob = RawBlob::create(buffer.getBuffer(), size); + + module = session->loadModuleFromIRBlob( + "module", + "path", + blob, + diagnostics.writeRef()); + } + + if (module) + { + ComPtr 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: diff --git a/tests/ir/dump-module.slang b/tests/ir/dump-module.slang new file mode 100644 index 0000000000..e22c3fca5d --- /dev/null +++ b/tests/ir/dump-module.slang @@ -0,0 +1,53 @@ +// This tests slangc's -dump-module command. +// Dumping ".slang" should mean just that, and it should not automatically load up +// a ".slang-module" when available, because the intent of the -dump-module command +// is to see the file you requested. If there's a bug in slang-module output, it's +// important that -dump-module looks at the specific file you requested. + +//TEST:COMPILE: tests/ir/dump-module.slang -o tests/ir/dump-module.slang-module -target spirv -embed-downstream-ir + +//TEST:SIMPLE(filecheck=CHECK1): -dump-module tests/ir/dump-module.slang-module +//TEST:SIMPLE(filecheck=CHECK2): -dump-module tests/ir/dump-module.slang + +module "export-library-generics"; + +public cbuffer Constants { + public float x; + public float y; +} + +interface MyInterface +{ + int myMethod(int a); +} + +struct MyType : MyInterface +{ + int myMethod(int a) + { + return a * 3; + } +} + +int genericFunc(T arg) +{ + return arg.myMethod(3); +} + +public int normalFuncUsesGeneric(int a) +{ + MyType obj; + return genericFunc(obj); +} + +public int normalFunc(int a, float b) +{ + return a - floor(b); +} + +// CHECK1:EmbeddedDownstreamIR(6 : Int, +// CHECK1: OpCapability Linkage + +// CHECK2-NOT:EmbeddedDownstreamIR(6 : Int, +// CHECK2-NOT: OpCapability Linkage +