From dfab34e4bf508fc517d4d645ebb3b6b1179a5003 Mon Sep 17 00:00:00 2001 From: Anders Leino Date: Fri, 11 Oct 2024 13:13:04 +0300 Subject: Add slang-wasm target (#5237) Support for exceptions is enabled, since Slang uses them for diagnostics. The size optimization arguments ('-Os') resolves some internal emscripten error during the slang-wasm.wasm linking step, which happens when enabling exceptions. ("parse exception: too many locals") --- source/compiler-core/slang-diagnostic-sink.cpp | 3 +- source/slang-wasm/slang-wasm-bindings.cpp | 59 ++++++++ source/slang-wasm/slang-wasm.cpp | 182 +++++++++++++++++++++++++ source/slang-wasm/slang-wasm.h | 107 +++++++++++++++ 4 files changed, 350 insertions(+), 1 deletion(-) create mode 100644 source/slang-wasm/slang-wasm-bindings.cpp create mode 100644 source/slang-wasm/slang-wasm.cpp create mode 100644 source/slang-wasm/slang-wasm.h (limited to 'source') diff --git a/source/compiler-core/slang-diagnostic-sink.cpp b/source/compiler-core/slang-diagnostic-sink.cpp index 7e3c286eb..a4cbce22f 100644 --- a/source/compiler-core/slang-diagnostic-sink.cpp +++ b/source/compiler-core/slang-diagnostic-sink.cpp @@ -574,7 +574,8 @@ bool DiagnosticSink::diagnoseImpl(DiagnosticInfo const& info, const UnownedStrin if (info.severity >= Severity::Fatal) { // TODO: figure out a better policy for aborting compilation - SLANG_ABORT_COMPILATION(""); + std::string message(formattedMessage.begin(), formattedMessage.end()); + SLANG_ABORT_COMPILATION(message.c_str()); } return true; } diff --git a/source/slang-wasm/slang-wasm-bindings.cpp b/source/slang-wasm/slang-wasm-bindings.cpp new file mode 100644 index 000000000..4880596a9 --- /dev/null +++ b/source/slang-wasm/slang-wasm-bindings.cpp @@ -0,0 +1,59 @@ +#include +#include +#include "slang-wasm.h" + +using namespace emscripten; + +EMSCRIPTEN_BINDINGS(slang) +{ + constant("SLANG_OK", SLANG_OK); + + function( + "createGlobalSession", + &slang::wgsl::createGlobalSession, + return_value_policy::take_ownership()); + + function( + "getLastError", + &slang::wgsl::getLastError); + + class_("GlobalSession") + .function( + "createSession", + &slang::wgsl::GlobalSession::createSession, + return_value_policy::take_ownership()); + + class_("Session") + .function( + "loadModuleFromSource", + &slang::wgsl::Session::loadModuleFromSource, + return_value_policy::take_ownership()) + .function( + "createCompositeComponentType", + &slang::wgsl::Session::createCompositeComponentType, + return_value_policy::take_ownership()); + + class_("ComponentType") + .function( + "link", + &slang::wgsl::ComponentType::link, + return_value_policy::take_ownership()) + .function( + "getEntryPointCode", + &slang::wgsl::ComponentType::getEntryPointCode); + + class_>("Module") + .function( + "findEntryPointByName", + &slang::wgsl::Module::findEntryPointByName, + return_value_policy::take_ownership()); + + value_object("Error") + .field("type", &slang::wgsl::Error::type) + .field("result", &slang::wgsl::Error::result) + .field("message", &slang::wgsl::Error::message); + + class_>("EntryPoint"); + + register_vector("ComponentTypeList"); +} diff --git a/source/slang-wasm/slang-wasm.cpp b/source/slang-wasm/slang-wasm.cpp new file mode 100644 index 000000000..c2cbe66b6 --- /dev/null +++ b/source/slang-wasm/slang-wasm.cpp @@ -0,0 +1,182 @@ +#include +#include +#include +#include +#include "slang-wasm.h" +#include "../core/slang-blob.h" +#include "../core/slang-exception.h" + +using namespace slang; + +namespace slang +{ +namespace wgsl +{ + +Error g_error; + +Error getLastError() +{ + Error currentError = g_error; + g_error = {}; + return currentError; +} + +GlobalSession* createGlobalSession() +{ + IGlobalSession* globalSession = nullptr; + { + SlangResult result = slang::createGlobalSession(&globalSession); + if (result != SLANG_OK) + { + g_error.type = std::string("USER"); + g_error.result = result; + return nullptr; + } + } + + return new GlobalSession(globalSession); +} + +Session* GlobalSession::createSession() +{ + ISession* session = nullptr; + { + SessionDesc sessionDesc = {}; + sessionDesc.structureSize = sizeof(sessionDesc); + constexpr SlangInt targetCount = 1; + TargetDesc targets[targetCount] = { + {.structureSize = sizeof(TargetDesc), .format = SLANG_WGSL} + }; + sessionDesc.targets = targets; + sessionDesc.targetCount = targetCount; + SlangResult result = m_interface->createSession(sessionDesc, &session); + if (result != SLANG_OK) + { + g_error.type = std::string("USER"); + g_error.result = result; + return nullptr; + } + } + + return new Session(session); +} + +Module* Session::loadModuleFromSource(const std::string& slangCode) +{ + Slang::ComPtr module; + { + const char * name = ""; + const char * path = ""; + Slang::ComPtr diagnosticsBlob; + Slang::ComPtr slangCodeBlob = Slang::RawBlob::create( + slangCode.c_str(), slangCode.size()); + module = m_interface->loadModuleFromSource( + name, path, slangCodeBlob, diagnosticsBlob.writeRef()); + if (!module) + { + g_error.type = std::string("USER"); + g_error.message = std::string( + (char*)diagnosticsBlob->getBufferPointer(), + (char*)diagnosticsBlob->getBufferPointer() + + diagnosticsBlob->getBufferSize()); + return nullptr; + } + } + + return new Module(module); +} + +EntryPoint* Module::findEntryPointByName(const std::string& name) +{ + Slang::ComPtr entryPoint; + { + SlangResult result = moduleInterface()->findEntryPointByName( + name.c_str(), entryPoint.writeRef()); + if (result != SLANG_OK) + { + g_error.type = std::string("USER"); + g_error.result = result; + return nullptr; + } + } + + return new EntryPoint(entryPoint); +} + +ComponentType* Session::createCompositeComponentType( + const std::vector& components) +{ + Slang::ComPtr composite; + { + std::vector nativeComponents(components.size()); + for (size_t i = 0U; i < components.size(); i++) + nativeComponents[i] = components[i]->interface(); + SlangResult result = m_interface->createCompositeComponentType( + nativeComponents.data(), + (SlangInt)nativeComponents.size(), + composite.writeRef()); + if (result != SLANG_OK) + { + g_error.type = std::string("USER"); + g_error.result = result; + return nullptr; + } + } + + return new ComponentType(composite); +} + +ComponentType* ComponentType::link() +{ + Slang::ComPtr linkedProgram; + { + Slang::ComPtr diagnosticBlob; + SlangResult result = interface()->link( + linkedProgram.writeRef(), diagnosticBlob.writeRef()); + if (result != SLANG_OK) + { + g_error.type = std::string("USER"); + g_error.result = result; + g_error.message = std::string( + (char*)diagnosticBlob->getBufferPointer(), + (char*)diagnosticBlob->getBufferPointer() + + diagnosticBlob->getBufferSize()); + return nullptr; + } + } + + return new ComponentType(linkedProgram); +} + +std::string ComponentType::getEntryPointCode(int entryPointIndex, int targetIndex) +{ + { + Slang::ComPtr kernelBlob; + Slang::ComPtr diagnosticBlob; + SlangResult result = interface()->getEntryPointCode( + entryPointIndex, + targetIndex, + kernelBlob.writeRef(), + diagnosticBlob.writeRef()); + if (result != SLANG_OK) + { + g_error.type = std::string("USER"); + g_error.result = result; + g_error.message = std::string( + (char*)diagnosticBlob->getBufferPointer(), + (char*)diagnosticBlob->getBufferPointer() + + diagnosticBlob->getBufferSize()); + return ""; + } + std::string wgslCode = std::string( + (char*)kernelBlob->getBufferPointer(), + (char*)kernelBlob->getBufferPointer() + kernelBlob->getBufferSize()); + return wgslCode; + } + + return {}; +} + +} // namespace wgsl +} // namespace slang diff --git a/source/slang-wasm/slang-wasm.h b/source/slang-wasm/slang-wasm.h new file mode 100644 index 000000000..24ce62392 --- /dev/null +++ b/source/slang-wasm/slang-wasm.h @@ -0,0 +1,107 @@ +#pragma once + +#include + +namespace slang +{ +namespace wgsl +{ + +class Error +{ +public: + // Can be + // "USER": User did not call the API correctly + // "INTERNAL": Slang failed due to a bug + std::string type; + std::string message; + SlangResult result; +}; + +Error getLastError(); + +class ComponentType +{ +public: + + ComponentType(slang::IComponentType* interface) : + m_interface(interface) {} + + ComponentType* link(); + + std::string getEntryPointCode(int entryPointIndex, int targetIndex); + + slang::IComponentType* interface() const {return m_interface;} + + virtual ~ComponentType() = default; + +private: + + Slang::ComPtr m_interface; +}; + +class EntryPoint : public ComponentType +{ +public: + + EntryPoint(slang::IEntryPoint* interface) : ComponentType(interface) {} + +private: + + slang::IEntryPoint* entryPointInterface() const { + return static_cast(interface()); + } +}; + +class Module : public ComponentType +{ +public: + + Module(slang::IModule* interface) : ComponentType(interface) {} + + EntryPoint* findEntryPointByName(const std::string& name); + + slang::IModule* moduleInterface() const { + return static_cast(interface()); + } +}; + +class Session +{ +public: + + Session(slang::ISession* interface) + : m_interface(interface) {} + + Module* loadModuleFromSource(const std::string& slangCode); + + ComponentType* createCompositeComponentType( + const std::vector& components); + + slang::ISession* interface() const {return m_interface;} + +private: + + Slang::ComPtr m_interface; +}; + +class GlobalSession +{ +public: + + GlobalSession(slang::IGlobalSession* interface) + : m_interface(interface) {} + + Session* createSession(); + + slang::IGlobalSession* interface() const {return m_interface;} + +private: + + Slang::ComPtr m_interface; +}; + +GlobalSession* createGlobalSession(); + +} // namespace wgsl +} // namespace slang -- cgit v1.2.3