diff options
25 files changed, 577 insertions, 100 deletions
diff --git a/docs/user-guide/08-compiling.md b/docs/user-guide/08-compiling.md index 147bc8144..c600b8cbb 100644 --- a/docs/user-guide/08-compiling.md +++ b/docs/user-guide/08-compiling.md @@ -589,12 +589,16 @@ A global session is created using the function `slang::createGlobalSession()`: using namespace slang; Slang::ComPtr<IGlobalSession> globalSession; -createGlobalSession(globalSession.writeRef()); +SlangGlobalSessionDesc desc = {}; +createGlobalSession(&desc, globalSession.writeRef()); ``` When a global session is created, the Slang system will load its internal representation of the _core module_ that the compiler provides to user code. The core module can take a significant amount of time to load, so applications are advised to use a single global session if possible, rather than creating and then disposing of one for each compile. +If you want to enable GLSL compatibility mode, you need to set `SlangGlobalSessionDesc::enableGLSL` to `true` when calling `createGlobalSession()`. This will load the necessary GLSL intrinsic module +for compiling GLSL code. Without this setting, compiling GLSL code will result in an error. + > #### Note #### > Currently, the global session type is *not* thread-safe. > Applications that wish to compile on multiple threads will need to ensure that each concurrent thread compiles with a distinct global session. @@ -874,6 +878,7 @@ The only functions which are currently thread safe are ```C++ SlangSession* spCreateSession(const char* deprecated); SlangResult slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession); +SlangResult slang_createGlobalSession2(const SlangGlobalSessionDesc* desc, slang::IGlobalSession** outGlobalSession); SlangResult slang_createGlobalSessionWithoutCoreModule(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession); ISlangBlob* slang_getEmbeddedCoreModule(); SlangResult slang::createGlobalSession(slang::IGlobalSession** outGlobalSession); diff --git a/include/slang.h b/include/slang.h index 356a2f496..333028a69 100644 --- a/include/slang.h +++ b/include/slang.h @@ -3520,6 +3520,12 @@ struct SessionDesc; struct SpecializationArg; struct TargetDesc; +enum class BuiltinModuleName +{ + Core, + GLSL +}; + /** A global session for interaction with the Slang library. An application may create and re-use a single global session across @@ -3750,6 +3756,36 @@ struct IGlobalSession : public ISlangUnknown */ virtual SLANG_NO_THROW SlangResult SLANG_MCALL getSessionDescDigest(SessionDesc* sessionDesc, ISlangBlob** outBlob) = 0; + + /** Compile from (embedded source) the builtin module on the session. + Will return a failure if there is already a builtin module available. + NOTE! API is experimental and not ready for production code. + @param module The builtin module name. + @param flags to control compilation + */ + virtual SLANG_NO_THROW SlangResult SLANG_MCALL + compileBuiltinModule(BuiltinModuleName module, CompileCoreModuleFlags flags) = 0; + + /** Load a builtin module. Currently loads modules from the file system. + @param module The builtin module name + @param moduleData Start address of the serialized core module + @param sizeInBytes The size in bytes of the serialized builtin module + + NOTE! API is experimental and not ready for production code + */ + virtual SLANG_NO_THROW SlangResult SLANG_MCALL + loadBuiltinModule(BuiltinModuleName module, const void* moduleData, size_t sizeInBytes) = 0; + + /** Save the builtin module to the file system + @param module The builtin module name + @param archiveType The type of archive used to hold the builtin module + @param outBlob The serialized blob containing the builtin module + + NOTE! API is experimental and not ready for production code */ + virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveBuiltinModule( + BuiltinModuleName module, + SlangArchiveType archiveType, + ISlangBlob** outBlob) = 0; }; #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid() @@ -4429,6 +4465,32 @@ struct SpecializationArg // using. #define SLANG_API_VERSION 0 +enum SlangLanguageVersion +{ + SLANG_LANGUAGE_VERSION_2025 = 2025 +}; + + +/* Description of a Slang global session. + */ +struct SlangGlobalSessionDesc +{ + /// Size of this struct. + uint32_t structureSize = sizeof(SlangGlobalSessionDesc); + + /// Slang API version. + uint32_t apiVersion = SLANG_API_VERSION; + + /// Slang language version. + uint32_t languageVersion = SLANG_LANGUAGE_VERSION_2025; + + /// Whether to enable GLSL support. + bool enableGLSL = false; + + /// Reserved for future use. + uint32_t reserved[16] = {}; +}; + /* Create a global session, with the built-in core module. @param apiVersion Pass in SLANG_API_VERSION @@ -4437,6 +4499,16 @@ struct SpecializationArg SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession); + +/* Create a global session, with the built-in core module. + +@param desc Description of the global session. +@param outGlobalSession (out)The created global session. +*/ +SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSession2( + const SlangGlobalSessionDesc* desc, + slang::IGlobalSession** outGlobalSession); + /* Create a global session, but do not set up the core module. The core module can then be loaded via loadCoreModule or compileCoreModule @@ -4472,7 +4544,14 @@ namespace slang { inline SlangResult createGlobalSession(slang::IGlobalSession** outGlobalSession) { - return slang_createGlobalSession(SLANG_API_VERSION, outGlobalSession); + SlangGlobalSessionDesc defaultDesc = {}; + return slang_createGlobalSession2(&defaultDesc, outGlobalSession); +} +inline SlangResult createGlobalSession( + const SlangGlobalSessionDesc* desc, + slang::IGlobalSession** outGlobalSession) +{ + return slang_createGlobalSession2(desc, outGlobalSession); } inline void shutdown() { diff --git a/source/slang-record-replay/record/parameter-recorder.cpp b/source/slang-record-replay/record/parameter-recorder.cpp index af4488f81..fd6f75549 100644 --- a/source/slang-record-replay/record/parameter-recorder.cpp +++ b/source/slang-record-replay/record/parameter-recorder.cpp @@ -2,6 +2,14 @@ namespace SlangRecord { +void ParameterRecorder::recordStruct(SlangGlobalSessionDesc const& desc) +{ + recordUint32(desc.structureSize); + recordUint32(desc.apiVersion); + recordUint32(desc.languageVersion); + recordUint32(desc.enableGLSL); +} + void ParameterRecorder::recordStruct(slang::SessionDesc const& desc) { recordUint64(desc.structureSize); diff --git a/source/slang-record-replay/record/parameter-recorder.h b/source/slang-record-replay/record/parameter-recorder.h index 05a16604e..24617b7b8 100644 --- a/source/slang-record-replay/record/parameter-recorder.h +++ b/source/slang-record-replay/record/parameter-recorder.h @@ -40,7 +40,7 @@ public: { recordValue(reinterpret_cast<SlangRecord::AddressFormat>(value)); } - + void recordStruct(SlangGlobalSessionDesc const& desc); void recordStruct(slang::SessionDesc const& desc); void recordStruct(slang::PreprocessorMacroDesc const& desc); void recordStruct(slang::CompilerOptionEntry const& entry); diff --git a/source/slang-record-replay/record/slang-global-session.cpp b/source/slang-record-replay/record/slang-global-session.cpp index 4f04574cd..eff9cf0ab 100644 --- a/source/slang-record-replay/record/slang-global-session.cpp +++ b/source/slang-record-replay/record/slang-global-session.cpp @@ -8,7 +8,9 @@ namespace SlangRecord { // constructor is called in slang_createGlobalSession -GlobalSessionRecorder::GlobalSessionRecorder(slang::IGlobalSession* session) +GlobalSessionRecorder::GlobalSessionRecorder( + const SlangGlobalSessionDesc* desc, + slang::IGlobalSession* session) : m_actualGlobalSession(session) { SLANG_RECORD_ASSERT(m_actualGlobalSession != nullptr); @@ -23,7 +25,10 @@ GlobalSessionRecorder::GlobalSessionRecorder(slang::IGlobalSession* session) ParameterRecorder* recorder{}; { - m_recordManager->beginMethodRecord(ApiCallId::CreateGlobalSession, g_globalFunctionHandle); + recorder = m_recordManager->beginMethodRecord( + ApiCallId::CreateGlobalSession, + g_globalFunctionHandle); + recorder->recordStruct(*desc); recorder = m_recordManager->endMethodRecord(); } @@ -416,6 +421,70 @@ GlobalSessionRecorder::saveCoreModule(SlangArchiveType archiveType, ISlangBlob** return res; } +SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::compileBuiltinModule( + slang::BuiltinModuleName module, + slang::CompileCoreModuleFlags flags) +{ + slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__); + + ParameterRecorder* recorder{}; + { + recorder = m_recordManager->beginMethodRecord( + ApiCallId::IGlobalSession_compileBuiltinModule, + m_globalSessionHandle); + recorder->recordEnumValue(module); + recorder->recordEnumValue(flags); + m_recordManager->endMethodRecord(); + } + + SlangResult res = m_actualGlobalSession->compileBuiltinModule(module, flags); + return res; +} + +SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::loadBuiltinModule( + slang::BuiltinModuleName module, + const void* moduleData, + size_t sizeInBytes) +{ + slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__); + + ParameterRecorder* recorder{}; + { + recorder = m_recordManager->beginMethodRecord( + ApiCallId::IGlobalSession_loadBuiltinModule, + m_globalSessionHandle); + recorder->recordEnumValue(module); + recorder->recordPointer(moduleData, false, sizeInBytes); + m_recordManager->endMethodRecord(); + } + + SlangResult res = m_actualGlobalSession->loadBuiltinModule(module, moduleData, sizeInBytes); + return res; +} +SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::saveBuiltinModule( + slang::BuiltinModuleName module, + SlangArchiveType archiveType, + ISlangBlob** outBlob) +{ + slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__); + + ParameterRecorder* recorder{}; + { + recorder = m_recordManager->beginMethodRecord( + ApiCallId::IGlobalSession_saveBuiltinModule, + m_globalSessionHandle); + recorder->recordEnumValue(module); + recorder->recordEnumValue(archiveType); + recorder = m_recordManager->endMethodRecord(); + } + SlangResult res = m_actualGlobalSession->saveBuiltinModule(module, archiveType, outBlob); + { + recorder->recordAddress(*outBlob); + m_recordManager->apendOutput(); + } + return res; +} + SLANG_NO_THROW SlangCapabilityID SLANG_MCALL GlobalSessionRecorder::findCapability(char const* name) { // No need to record this function. It's just a query function and it won't impact the internal diff --git a/source/slang-record-replay/record/slang-global-session.h b/source/slang-record-replay/record/slang-global-session.h index f6c976f72..fd2099153 100644 --- a/source/slang-record-replay/record/slang-global-session.h +++ b/source/slang-record-replay/record/slang-global-session.h @@ -14,7 +14,9 @@ using namespace Slang; class GlobalSessionRecorder : public RefObject, public slang::IGlobalSession { public: - explicit GlobalSessionRecorder(slang::IGlobalSession* session); + explicit GlobalSessionRecorder( + const SlangGlobalSessionDesc* desc, + slang::IGlobalSession* session); SLANG_REF_OBJECT_IUNKNOWN_ADD_REF SLANG_REF_OBJECT_IUNKNOWN_RELEASE @@ -64,6 +66,18 @@ public: SLANG_NO_THROW SlangResult SLANG_MCALL saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob) override; + virtual SLANG_NO_THROW SlangResult SLANG_MCALL compileBuiltinModule( + slang::BuiltinModuleName module, + slang::CompileCoreModuleFlags flags) override; + virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadBuiltinModule( + slang::BuiltinModuleName module, + const void* moduleData, + size_t sizeInBytes) override; + virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveBuiltinModule( + slang::BuiltinModuleName module, + SlangArchiveType archiveType, + ISlangBlob** outBlob) override; + SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(char const* name) override; SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerForTransition( diff --git a/source/slang-record-replay/replay/decoder-consumer.h b/source/slang-record-replay/replay/decoder-consumer.h index 31c10bdab..389b286d3 100644 --- a/source/slang-record-replay/replay/decoder-consumer.h +++ b/source/slang-record-replay/replay/decoder-consumer.h @@ -11,7 +11,9 @@ namespace SlangRecord class IDecoderConsumer { public: - virtual void CreateGlobalSession(ObjectID outGlobalSessionId) = 0; + virtual void CreateGlobalSession( + SlangGlobalSessionDesc const& desc, + ObjectID outGlobalSessionId) = 0; virtual void IGlobalSession_createSession( ObjectID objectId, slang::SessionDesc const& desc, diff --git a/source/slang-record-replay/replay/decoder-helper.cpp b/source/slang-record-replay/replay/decoder-helper.cpp index 0c8240617..1b36df1ad 100644 --- a/source/slang-record-replay/replay/decoder-helper.cpp +++ b/source/slang-record-replay/replay/decoder-helper.cpp @@ -54,6 +54,7 @@ size_t BlobDecoder::decode(const uint8_t* buffer, int64_t bufferSize) return readByte; } +template class StructDecoder<SlangGlobalSessionDesc>; template class StructDecoder<slang::SessionDesc>; template class StructDecoder<slang::PreprocessorMacroDesc>; template class StructDecoder<slang::CompilerOptionEntry>; diff --git a/source/slang-record-replay/replay/json-consumer.cpp b/source/slang-record-replay/replay/json-consumer.cpp index 45d23667b..c0486341e 100644 --- a/source/slang-record-replay/replay/json-consumer.cpp +++ b/source/slang-record-replay/replay/json-consumer.cpp @@ -618,6 +618,24 @@ void JsonConsumer::_writeCompilerOptionEntryHelper( } } +void JsonConsumer::_writeGlobalSessionDescHelper( + Slang::StringBuilder& builder, + int indent, + SlangGlobalSessionDesc const& desc, + Slang::String keyName, + bool isLastField) +{ + SLANG_UNUSED(isLastField); + + ScopeWritterForKey scopeWritterForGlobalSessionDesc(&builder, &indent, keyName); + { + _writePair(builder, indent, "structureSize", (uint32_t)desc.structureSize); + _writePair(builder, indent, "apiVersion", (uint32_t)desc.apiVersion); + _writePair(builder, indent, "languageVersion", (uint32_t)desc.languageVersion); + _writePair(builder, indent, "enablGLSL", (uint32_t)desc.enableGLSL); + } +} + void JsonConsumer::_writeSessionDescHelper( Slang::StringBuilder& builder, int indent, @@ -779,7 +797,9 @@ void JsonConsumer::_writeSessionDescHelper( } } -void JsonConsumer::CreateGlobalSession(ObjectID outGlobalSessionId) +void JsonConsumer::CreateGlobalSession( + SlangGlobalSessionDesc const& desc, + ObjectID outGlobalSessionId) { SANITY_CHECK(); Slang::StringBuilder builder; @@ -787,6 +807,7 @@ void JsonConsumer::CreateGlobalSession(ObjectID outGlobalSessionId) { ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::createGlobalSession"); + _writeGlobalSessionDescHelper(builder, indent, desc, "inDesc"); _writePairNoComma( builder, indent, diff --git a/source/slang-record-replay/replay/json-consumer.h b/source/slang-record-replay/replay/json-consumer.h index 4eb03ba0a..2f4b62a46 100644 --- a/source/slang-record-replay/replay/json-consumer.h +++ b/source/slang-record-replay/replay/json-consumer.h @@ -92,7 +92,9 @@ class JsonConsumer : public IDecoderConsumer, public Slang::RefObject public: JsonConsumer(const Slang::String& filePath); virtual ~JsonConsumer() = default; - virtual void CreateGlobalSession(ObjectID outGlobalSessionId); + virtual void CreateGlobalSession( + SlangGlobalSessionDesc const& desc, + ObjectID outGlobalSessionId); virtual void IGlobalSession_createSession( ObjectID objectId, slang::SessionDesc const& desc, @@ -540,6 +542,12 @@ public: slang::CompilerOptionEntry* compilerOptionEntries, uint32_t compilerOptionEntryCount, bool isLast = false); + static void _writeGlobalSessionDescHelper( + Slang::StringBuilder& builder, + int indent, + SlangGlobalSessionDesc const& globalSessionDesc, + Slang::String keyName, + bool isLast = false); static void _writeSessionDescHelper( Slang::StringBuilder& builder, int indent, diff --git a/source/slang-record-replay/replay/parameter-decoder.cpp b/source/slang-record-replay/replay/parameter-decoder.cpp index 824b69de8..afe4f716d 100644 --- a/source/slang-record-replay/replay/parameter-decoder.cpp +++ b/source/slang-record-replay/replay/parameter-decoder.cpp @@ -71,6 +71,30 @@ size_t ParameterDecoder::decodePointer( size_t ParameterDecoder::decodeStruct( const uint8_t* buffer, int64_t bufferSize, + ValueDecoder<SlangGlobalSessionDesc>& sessionDesc) +{ + SLANG_RECORD_ASSERT((buffer != nullptr) && (bufferSize > 0)); + + if (bufferSize < (int64_t)sizeof(uint64_t)) + { + return 0; + } + + size_t readByte = 0; + SlangGlobalSessionDesc& desc = sessionDesc.getValue(); + readByte = decodeUint32(buffer, bufferSize, desc.structureSize); + readByte += decodeUint32(buffer + readByte, bufferSize - readByte, desc.apiVersion); + readByte += decodeUint32(buffer + readByte, bufferSize - readByte, desc.languageVersion); + uint32_t val = 0; + readByte += decodeUint32(buffer + readByte, bufferSize - readByte, val); + desc.enableGLSL = (val != 0); + + return readByte; +} + +size_t ParameterDecoder::decodeStruct( + const uint8_t* buffer, + int64_t bufferSize, ValueDecoder<slang::SessionDesc>& sessionDesc) { SLANG_RECORD_ASSERT((buffer != nullptr) && (bufferSize > 0)); diff --git a/source/slang-record-replay/replay/parameter-decoder.h b/source/slang-record-replay/replay/parameter-decoder.h index 50cbc69ad..8c3fd3d80 100644 --- a/source/slang-record-replay/replay/parameter-decoder.h +++ b/source/slang-record-replay/replay/parameter-decoder.h @@ -90,6 +90,10 @@ public: static size_t decodeStruct( const uint8_t* buffer, int64_t bufferSize, + ValueDecoder<SlangGlobalSessionDesc>& sessionDesc); + static size_t decodeStruct( + const uint8_t* buffer, + int64_t bufferSize, ValueDecoder<slang::SessionDesc>& sessionDesc); static size_t decodeStruct( const uint8_t* buffer, diff --git a/source/slang-record-replay/replay/replay-consumer.cpp b/source/slang-record-replay/replay/replay-consumer.cpp index 9dd087e63..56e1a41b9 100644 --- a/source/slang-record-replay/replay/replay-consumer.cpp +++ b/source/slang-record-replay/replay/replay-consumer.cpp @@ -330,12 +330,14 @@ void ReplayConsumer::printDiagnosticMessage(slang::IBlob* diagnosticsBlob) } } -void ReplayConsumer::CreateGlobalSession(ObjectID outGlobalSessionId) +void ReplayConsumer::CreateGlobalSession( + SlangGlobalSessionDesc const& desc, + ObjectID outGlobalSessionId) { OutputObjectSanityCheck(outGlobalSessionId); slang::IGlobalSession* outGlobalSession{}; - slang::createGlobalSession(&outGlobalSession); + slang::createGlobalSession(&desc, &outGlobalSession); if (outGlobalSession) { diff --git a/source/slang-record-replay/replay/replay-consumer.h b/source/slang-record-replay/replay/replay-consumer.h index 7f4c3b5e1..733f8127a 100644 --- a/source/slang-record-replay/replay/replay-consumer.h +++ b/source/slang-record-replay/replay/replay-consumer.h @@ -96,7 +96,9 @@ private: class ReplayConsumer : public IDecoderConsumer, public Slang::RefObject { public: - virtual void CreateGlobalSession(ObjectID outGlobalSessionId) override; + virtual void CreateGlobalSession( + SlangGlobalSessionDesc const& desc, + ObjectID outGlobalSessionId) override; virtual void IGlobalSession_createSession( ObjectID objectId, slang::SessionDesc const& desc, diff --git a/source/slang-record-replay/replay/slang-decoder.cpp b/source/slang-record-replay/replay/slang-decoder.cpp index 7d9648a2a..4b5606b76 100644 --- a/source/slang-record-replay/replay/slang-decoder.cpp +++ b/source/slang-record-replay/replay/slang-decoder.cpp @@ -446,6 +446,9 @@ bool SlangDecoder::processFunctionCall( bool SlangDecoder::CreateGlobalSession(ParameterBlock const& parameterBlock) { + StructDecoder<SlangGlobalSessionDesc> sessionDesc; + sessionDesc.decode(parameterBlock.parameterBuffer, parameterBlock.parameterBufferSize); + ObjectID outGlobalSessionId = 0; ParameterDecoder::decodeAddress( parameterBlock.outputBuffer, @@ -454,7 +457,7 @@ bool SlangDecoder::CreateGlobalSession(ParameterBlock const& parameterBlock) for (auto consumer : m_consumers) { - consumer->CreateGlobalSession(outGlobalSessionId); + consumer->CreateGlobalSession(sessionDesc.getValue(), outGlobalSessionId); } return true; } diff --git a/source/slang-record-replay/util/record-format.h b/source/slang-record-replay/util/record-format.h index 2620b49f9..f1ae2e71b 100644 --- a/source/slang-record-replay/util/record-format.h +++ b/source/slang-record-replay/util/record-format.h @@ -89,6 +89,9 @@ enum ApiCallId : uint32_t IGlobalSession_setSPIRVCoreGrammar = makeApiCallId(Class_IGlobalSession, 0x0018), IGlobalSession_parseCommandLineArguments = makeApiCallId(Class_IGlobalSession, 0x0019), IGlobalSession_getSessionDescDigest = makeApiCallId(Class_IGlobalSession, 0x001A), + IGlobalSession_compileBuiltinModule = makeApiCallId(Class_IGlobalSession, 0x001B), + IGlobalSession_loadBuiltinModule = makeApiCallId(Class_IGlobalSession, 0x001C), + IGlobalSession_saveBuiltinModule = makeApiCallId(Class_IGlobalSession, 0x001D), ISession_getGlobalSession = makeApiCallId(Class_ISession, 0x0001), ISession_loadModule = makeApiCallId(Class_ISession, 0x0002), diff --git a/source/slang/slang-api.cpp b/source/slang/slang-api.cpp index e510fc9a2..16d6a07f1 100644 --- a/source/slang/slang-api.cpp +++ b/source/slang/slang-api.cpp @@ -23,11 +23,12 @@ SLANG_API SlangSession* spCreateSession(const char*) return globalSession.detach(); } -// Attempt to load a previously compiled core module from the same file system location as the slang -// dll. Returns SLANG_OK when the cache is sucessfully loaded. Also returns the filename to the core -// module cache and the timestamp of current slang dll. -SlangResult tryLoadCoreModuleFromCache( +// Attempt to load a previously compiled builtin module from the same file system location as the +// slang dll. Returns SLANG_OK when the cache is sucessfully loaded. Also returns the filename to +// the builtin module cache and the timestamp of current slang dll. +SlangResult tryLoadBuiltinModuleFromCache( slang::IGlobalSession* globalSession, + slang::BuiltinModuleName builtinModuleName, Slang::String& outCachePath, uint64_t& outTimestamp) { @@ -36,7 +37,10 @@ SlangResult tryLoadCoreModuleFromCache( uint64_t currentLibTimestamp = Slang::SharedLibraryUtils::getSharedLibraryTimestamp((void*)slang_createGlobalSession); auto dirName = Slang::Path::getParentDirectory(fileName); - auto cacheFileName = Slang::Path::combine(dirName, "slang-core-module.bin"); + auto cacheFileName = Slang::Path::combine( + dirName, + Slang::String("slang-") + Slang::getBuiltinModuleNameStr(builtinModuleName) + + "-module.bin"); outTimestamp = currentLibTimestamp; outCachePath = cacheFileName; if (currentLibTimestamp == 0) @@ -52,21 +56,24 @@ SlangResult tryLoadCoreModuleFromCache( auto cacheTimestamp = *(uint64_t*)(cacheData.getData()); if (cacheTimestamp != currentLibTimestamp) return SLANG_FAIL; - SLANG_RETURN_ON_FAIL(globalSession->loadCoreModule( + SLANG_RETURN_ON_FAIL(globalSession->loadBuiltinModule( + builtinModuleName, (uint8_t*)cacheData.getData() + sizeof(uint64_t), cacheData.getSizeInBytes() - sizeof(uint64_t))); return SLANG_OK; } -SlangResult trySaveCoreModuleToCache( +SlangResult trySaveBuiltinModuleToCache( slang::IGlobalSession* globalSession, + slang::BuiltinModuleName builtinModuleName, const Slang::String& cacheFilename, uint64_t dllTimestamp) { if (dllTimestamp != 0 && cacheFilename.getLength() != 0) { Slang::ComPtr<ISlangBlob> coreModuleBlobPtr; - SLANG_RETURN_ON_FAIL(globalSession->saveCoreModule( + SLANG_RETURN_ON_FAIL(globalSession->saveBuiltinModule( + builtinModuleName, SLANG_ARCHIVE_TYPE_RIFF_LZ4, coreModuleBlobPtr.writeRef())); @@ -85,6 +92,15 @@ SlangResult trySaveCoreModuleToCache( SLANG_API SlangResult slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession) { + SlangGlobalSessionDesc desc = {}; + desc.apiVersion = (uint32_t)apiVersion; + return slang_createGlobalSession2(&desc, outGlobalSession); +} + +SLANG_API SlangResult slang_createGlobalSession2( + const SlangGlobalSessionDesc* desc, + slang::IGlobalSession** outGlobalSession) +{ Slang::ComPtr<slang::IGlobalSession> globalSession; #ifdef SLANG_ENABLE_IR_BREAK_ALLOC @@ -94,7 +110,7 @@ slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobal #endif SLANG_RETURN_ON_FAIL( - slang_createGlobalSessionWithoutCoreModule(apiVersion, globalSession.writeRef())); + slang_createGlobalSessionWithoutCoreModule(desc->apiVersion, globalSession.writeRef())); // If we have the embedded core module, load from that, else compile it ISlangBlob* coreModuleBlob = slang_getEmbeddedCoreModule(); @@ -112,17 +128,48 @@ slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobal #if SLANG_PROFILE_CORE_MODULE_COMPILE auto startTime = std::chrono::high_resolution_clock::now(); #else - if (tryLoadCoreModuleFromCache(globalSession, cacheFilename, dllTimestamp) != SLANG_OK) + if (tryLoadBuiltinModuleFromCache( + globalSession, + slang::BuiltinModuleName::Core, + cacheFilename, + dllTimestamp) != SLANG_OK) #endif { // Compile std lib from embeded source. - SLANG_RETURN_ON_FAIL(globalSession->compileCoreModule(0)); + SLANG_RETURN_ON_FAIL( + globalSession->compileBuiltinModule(slang::BuiltinModuleName::Core, 0)); #if SLANG_PROFILE_CORE_MODULE_COMPILE auto timeElapsed = std::chrono::high_resolution_clock::now() - startTime; printf("core module compilation time: %.1fms\n", timeElapsed.count() / 1000000.0); #endif // Store the compiled core module to cache file. - trySaveCoreModuleToCache(globalSession, cacheFilename, dllTimestamp); + trySaveBuiltinModuleToCache( + globalSession, + slang::BuiltinModuleName::Core, + cacheFilename, + dllTimestamp); + } + } + + if (desc->enableGLSL) + { + Slang::String cacheFilename; + uint64_t dllTimestamp = 0; + if (tryLoadBuiltinModuleFromCache( + globalSession, + slang::BuiltinModuleName::GLSL, + cacheFilename, + dllTimestamp) != SLANG_OK) + { + SLANG_RETURN_ON_FAIL( + globalSession->compileBuiltinModule(slang::BuiltinModuleName::GLSL, 0)); + + // Store the compiled core module to cache file. + trySaveBuiltinModuleToCache( + globalSession, + slang::BuiltinModuleName::GLSL, + cacheFilename, + dllTimestamp); } } @@ -130,7 +177,7 @@ slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobal if (SlangRecord::isRecordLayerEnabled()) { SlangRecord::GlobalSessionRecorder* globalSessionRecorder = - new SlangRecord::GlobalSessionRecorder(globalSession.detach()); + new SlangRecord::GlobalSessionRecorder(desc, globalSession.detach()); Slang::ComPtr<SlangRecord::GlobalSessionRecorder> result(globalSessionRecorder); *outGlobalSession = result.detach(); } diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index cc4fc8dcc..38725fff3 100644 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -3430,6 +3430,18 @@ public: SLANG_NO_THROW SlangResult SLANG_MCALL saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob) override; + SLANG_NO_THROW SlangResult SLANG_MCALL compileBuiltinModule( + slang::BuiltinModuleName moduleName, + slang::CompileCoreModuleFlags flags) override; + SLANG_NO_THROW SlangResult SLANG_MCALL loadBuiltinModule( + slang::BuiltinModuleName moduleName, + const void* coreModule, + size_t coreModuleSizeInBytes) override; + SLANG_NO_THROW SlangResult SLANG_MCALL saveBuiltinModule( + slang::BuiltinModuleName moduleName, + SlangArchiveType archiveType, + ISlangBlob** outBlob) override; + SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(char const* name) override; SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerForTransition( @@ -3470,7 +3482,8 @@ public: Scope* coreLanguageScope = nullptr; Scope* hlslLanguageScope = nullptr; Scope* slangLanguageScope = nullptr; - Scope* autodiffLanguageScope = nullptr; + Scope* glslLanguageScope = nullptr; + Name* glslModuleName = nullptr; ModuleDecl* baseModuleDecl = nullptr; List<RefPtr<Module>> coreModules; @@ -3543,11 +3556,17 @@ public: /// Get the built in linkage -> handy to get the core module from Linkage* getBuiltinLinkage() const { return m_builtinLinkage; } + Module* getBuiltinModule(slang::BuiltinModuleName builtinModuleName); + Name* getCompletionRequestTokenName() const { return m_completionTokenName; } void init(); - void addBuiltinSource(Scope* scope, String const& path, ISlangBlob* sourceBlob); + void addBuiltinSource( + Scope* scope, + String const& path, + ISlangBlob* sourceBlob, + Module*& outModule); ~Session(); void addDownstreamCompileTime(double time) { m_downstreamCompileTime += time; } @@ -3571,9 +3590,21 @@ public: int m_typeDictionarySize = 0; private: + struct BuiltinModuleInfo + { + const char* name; + Scope* languageScope; + }; + + BuiltinModuleInfo getBuiltinModuleInfo(slang::BuiltinModuleName name); + void _initCodeGenTransitionMap(); - SlangResult _readBuiltinModule(ISlangFileSystem* fileSystem, Scope* scope, String moduleName); + SlangResult _readBuiltinModule( + ISlangFileSystem* fileSystem, + Scope* scope, + String moduleName, + Module*& outModule); SlangResult _loadRequest(EndToEndCompileRequest* request, const void* data, size_t size); @@ -3592,6 +3623,8 @@ private: double m_totalCompileTime = 0.0; }; +const char* getBuiltinModuleNameStr(slang::BuiltinModuleName name); + void checkTranslationUnit( TranslationUnitRequest* translationUnit, LoadedModuleDictionary& loadedModules); diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h index fa96b89f9..ca99ac11d 100644 --- a/source/slang/slang-diagnostic-defs.h +++ b/source/slang/slang-diagnostic-defs.h @@ -1856,6 +1856,13 @@ DIAGNOSTIC( Error, errorInImportedModule, "import of module '$0' failed because of a compilation error") + +DIAGNOSTIC( + 38201, + Error, + glslModuleNotAvailable, + "'glsl' module is not available from the current global session. To enable GLSL compatibility " + "mode, specify 'SlangGlobalSessionDesc::enableGLSL' when creating the global session.") DIAGNOSTIC(39999, Fatal, complationCeased, "compilation ceased") // 39xxx - Type layout and parameter binding. diff --git a/source/slang/slang-language-server.cpp b/source/slang/slang-language-server.cpp index f9cc6f711..43e5b31ef 100644 --- a/source/slang/slang-language-server.cpp +++ b/source/slang/slang-language-server.cpp @@ -82,7 +82,9 @@ slang::IGlobalSession* LanguageServerCore::getOrCreateGlobalSession() if (!m_session) { // Just create the global session in the regular way if there isn't one set - if (SLANG_FAILED(slang_createGlobalSession(SLANG_API_VERSION, m_session.writeRef()))) + SlangGlobalSessionDesc desc = {}; + desc.enableGLSL = true; + if (SLANG_FAILED(slang_createGlobalSession2(&desc, m_session.writeRef()))) { return nullptr; } diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index 6a242d5ce..8d73cc0ef 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -18,6 +18,7 @@ #include "../core/slang-file-system.h" #include "../core/slang-memory-file-system.h" #include "../core/slang-writer.h" +#include "core/slang-shared-library.h" #include "slang-ast-dump.h" #include "slang-check-impl.h" #include "slang-check.h" @@ -220,15 +221,17 @@ void Session::init() coreLanguageScope = builtinAstBuilder->create<Scope>(); coreLanguageScope->nextSibling = baseLanguageScope; - autodiffLanguageScope = builtinAstBuilder->create<Scope>(); - autodiffLanguageScope->nextSibling = coreLanguageScope; - hlslLanguageScope = builtinAstBuilder->create<Scope>(); - hlslLanguageScope->nextSibling = autodiffLanguageScope; + hlslLanguageScope->nextSibling = coreLanguageScope; slangLanguageScope = builtinAstBuilder->create<Scope>(); slangLanguageScope->nextSibling = hlslLanguageScope; + glslLanguageScope = builtinAstBuilder->create<Scope>(); + glslLanguageScope->nextSibling = slangLanguageScope; + + glslModuleName = getNameObj("glsl"); + { for (Index i = 0; i < Index(SourceLanguage::CountOf); ++i) { @@ -248,6 +251,17 @@ void Session::init() spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::getEmbeddedVersion(); } +Module* Session::getBuiltinModule(slang::BuiltinModuleName name) +{ + auto info = getBuiltinModuleInfo(name); + auto builtinLinkage = getBuiltinLinkage(); + auto moduleNameObj = builtinLinkage->getNamePool()->getName(info.name); + RefPtr<Module> module; + if (builtinLinkage->mapNameToLoadedModules.tryGetValue(moduleNameObj, module)) + return module.get(); + return nullptr; +} + void Session::_initCodeGenTransitionMap() { // TODO(JS): Might want to do something about these in the future... @@ -314,7 +328,10 @@ void Session::addBuiltins(char const* sourcePath, char const* source) auto sourceBlob = StringBlob::moveCreate(String(source)); // TODO(tfoley): Add ability to directly new builtins to the appropriate scope - addBuiltinSource(coreLanguageScope, sourcePath, sourceBlob); + Module* module = nullptr; + addBuiltinSource(coreLanguageScope, sourcePath, sourceBlob, module); + if (module) + coreModules.add(module); } void Session::setSharedLibraryLoader(ISlangSharedLibraryLoader* loader) @@ -376,31 +393,101 @@ void Session::writeCoreModuleDoc(String config) } } -SlangResult Session::compileCoreModule(slang::CompileCoreModuleFlags compileFlags) +const char* getBuiltinModuleNameStr(slang::BuiltinModuleName name) { - SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder()); + const char* result = nullptr; + switch (name) + { + case slang::BuiltinModuleName::Core: + result = "core"; + break; + case slang::BuiltinModuleName::GLSL: + result = "glsl"; + break; + default: + SLANG_UNEXPECTED("Unknown builtin module"); + } + return result; +} + +Session::BuiltinModuleInfo Session::getBuiltinModuleInfo(slang::BuiltinModuleName name) +{ + Session::BuiltinModuleInfo result; - if (m_builtinLinkage->mapNameToLoadedModules.getCount()) + result.name = getBuiltinModuleNameStr(name); + + switch (name) { - // Already have a core module loaded - return SLANG_FAIL; + case slang::BuiltinModuleName::Core: + result.languageScope = coreLanguageScope; + break; + case slang::BuiltinModuleName::GLSL: + result.name = "glsl"; + result.languageScope = glslLanguageScope; + break; + default: + SLANG_UNEXPECTED("Unknown builtin module"); } + return result; +} + +SlangResult Session::compileCoreModule(slang::CompileCoreModuleFlags compileFlags) +{ + return compileBuiltinModule(slang::BuiltinModuleName::Core, compileFlags); +} + +SlangResult Session::compileBuiltinModule( + slang::BuiltinModuleName moduleName, + slang::CompileCoreModuleFlags compileFlags) +{ + SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder()); #ifdef _DEBUG - // Print a message in debug builds to notice the user that compiling the core module - // can take a while. - time_t beginTime; - time(&beginTime); - fprintf(stderr, "Compiling core module on debug build, this can take a while.\n"); + time_t beginTime = 0; + if (moduleName == slang::BuiltinModuleName::Core) + { + // Print a message in debug builds to notice the user that compiling the core module + // can take a while. + time(&beginTime); + fprintf(stderr, "Compiling core module on debug build, this can take a while.\n"); + } #endif + BuiltinModuleInfo builtinModuleInfo = getBuiltinModuleInfo(moduleName); + auto moduleNameObj = m_builtinLinkage->getNamePool()->getName(builtinModuleInfo.name); + if (m_builtinLinkage->mapNameToLoadedModules.tryGetValue(moduleNameObj)) + { + // Already have the builtin module loaded + return SLANG_FAIL; + } - // TODO(JS): Could make this return a SlangResult as opposed to exception - StringBuilder coreModuleSrcBuilder; - coreModuleSrcBuilder << (const char*)getCoreLibraryCode()->getBufferPointer() + StringBuilder moduleSrcBuilder; + switch (moduleName) + { + case slang::BuiltinModuleName::Core: + moduleSrcBuilder << (const char*)getCoreLibraryCode()->getBufferPointer() << (const char*)getHLSLLibraryCode()->getBufferPointer() << (const char*)getAutodiffLibraryCode()->getBufferPointer(); - auto coreModuleSrcBlob = StringBlob::moveCreate(coreModuleSrcBuilder.produceString()); - addBuiltinSource(coreLanguageScope, "core", coreModuleSrcBlob); + break; + case slang::BuiltinModuleName::GLSL: + moduleSrcBuilder << (const char*)getGLSLLibraryCode()->getBufferPointer(); + break; + } + + // TODO(JS): Could make this return a SlangResult as opposed to exception + auto moduleSrcBlob = StringBlob::moveCreate(moduleSrcBuilder.produceString()); + Module* compiledModule = nullptr; + addBuiltinSource( + builtinModuleInfo.languageScope, + builtinModuleInfo.name, + moduleSrcBlob, + compiledModule); + + if (moduleName == slang::BuiltinModuleName::Core) + { + // We need to retain this AST so that we can use it in other code + // (Note that the `Scope` type does not retain the AST it points to) + coreModules.add(compiledModule); + } if (compileFlags & slang::CompileCoreModuleFlag::WriteDocumentation) { @@ -422,31 +509,57 @@ SlangResult Session::compileCoreModule(slang::CompileCoreModuleFlags compileFlag finalizeSharedASTBuilder(); #ifdef _DEBUG - time_t endTime; - time(&endTime); - fprintf(stderr, "Compiling core module took %.2f seconds.\n", difftime(endTime, beginTime)); + if (moduleName == slang::BuiltinModuleName::Core) + { + time_t endTime; + time(&endTime); + fprintf(stderr, "Compiling core module took %.2f seconds.\n", difftime(endTime, beginTime)); + } #endif return SLANG_OK; } SlangResult Session::loadCoreModule(const void* coreModule, size_t coreModuleSizeInBytes) { + return loadBuiltinModule(slang::BuiltinModuleName::Core, coreModule, coreModuleSizeInBytes); +} + +SlangResult Session::loadBuiltinModule( + slang::BuiltinModuleName moduleName, + const void* moduleData, + size_t sizeInBytes) +{ SLANG_PROFILE; - if (m_builtinLinkage->mapNameToLoadedModules.getCount()) + + SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder()); + + BuiltinModuleInfo builtinModuleInfo = getBuiltinModuleInfo(moduleName); + auto nameObj = m_builtinLinkage->getNamePool()->getName(builtinModuleInfo.name); + if (m_builtinLinkage->mapNameToLoadedModules.containsKey(nameObj)) { // Already have a core module loaded return SLANG_FAIL; } - SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder()); - // Make a file system to read it from ComPtr<ISlangFileSystemExt> fileSystem; - SLANG_RETURN_ON_FAIL(loadArchiveFileSystem(coreModule, coreModuleSizeInBytes, fileSystem)); + SLANG_RETURN_ON_FAIL(loadArchiveFileSystem(moduleData, sizeInBytes, fileSystem)); // Let's try loading serialized modules and adding them - SLANG_RETURN_ON_FAIL(_readBuiltinModule(fileSystem, coreLanguageScope, "core")); + Module* module = nullptr; + SLANG_RETURN_ON_FAIL(_readBuiltinModule( + fileSystem, + builtinModuleInfo.languageScope, + builtinModuleInfo.name, + module)); + + if (moduleName == slang::BuiltinModuleName::Core) + { + // We need to retain this AST so that we can use it in other code + // (Note that the `Scope` type does not retain the AST it points to) + coreModules.add(module); + } finalizeSharedASTBuilder(); return SLANG_OK; @@ -454,12 +567,22 @@ SlangResult Session::loadCoreModule(const void* coreModule, size_t coreModuleSiz SlangResult Session::saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob) { + return saveBuiltinModule(slang::BuiltinModuleName::Core, archiveType, outBlob); +} + +SlangResult Session::saveBuiltinModule( + slang::BuiltinModuleName builtinModuleName, + SlangArchiveType archiveType, + ISlangBlob** outBlob) +{ if (m_builtinLinkage->mapNameToLoadedModules.getCount() == 0) { // There is no standard lib loaded return SLANG_FAIL; } + BuiltinModuleInfo builtinModuleInfo = getBuiltinModuleInfo(builtinModuleName); + // Make a file system to read it from ComPtr<ISlangMutableFileSystem> fileSystem; SLANG_RETURN_ON_FAIL(createArchiveFileSystem(archiveType, fileSystem)); @@ -471,32 +594,38 @@ SlangResult Session::saveCoreModule(SlangArchiveType archiveType, ISlangBlob** o return SLANG_FAIL; } + RefPtr<Module> module; + m_builtinLinkage->mapNameToLoadedModules.tryGetValue( + getNameObj(UnownedStringSlice(builtinModuleInfo.name)), + module); + if (!module) + { + return SLANG_FAIL; + } + SLANG_AST_BUILDER_RAII(m_builtinLinkage->getASTBuilder()); - for (const auto& [moduleName, module] : m_builtinLinkage->mapNameToLoadedModules) - { - // Set up options - SerialContainerUtil::WriteOptions options; + // Set up options + SerialContainerUtil::WriteOptions options; - // Save with SourceLocation information - options.optionFlags |= SerialOptionFlag::SourceLocation; + // Save with SourceLocation information + options.optionFlags |= SerialOptionFlag::SourceLocation; - // TODO(JS): Should this be the Session::getBuiltinSourceManager()? - options.sourceManager = m_builtinLinkage->getSourceManager(); + // TODO(JS): Should this be the Session::getBuiltinSourceManager()? + options.sourceManager = m_builtinLinkage->getSourceManager(); - StringBuilder builder; - builder << moduleName->text << ".slang-module"; + StringBuilder builder; + builder << builtinModuleInfo.name << ".slang-module"; - OwnedMemoryStream stream(FileAccess::Write); + OwnedMemoryStream stream(FileAccess::Write); - SLANG_RETURN_ON_FAIL(SerialContainerUtil::write(module, options, &stream)); + SLANG_RETURN_ON_FAIL(SerialContainerUtil::write(module, options, &stream)); - auto contents = stream.getContents(); + auto contents = stream.getContents(); - // Write into the file system - SLANG_RETURN_ON_FAIL( - fileSystem->saveFile(builder.getBuffer(), contents.getBuffer(), contents.getCount())); - } + // Write into the file system + SLANG_RETURN_ON_FAIL( + fileSystem->saveFile(builder.getBuffer(), contents.getBuffer(), contents.getCount())); // Now need to convert into a blob SLANG_RETURN_ON_FAIL(archiveFileSystem->storeArchive(true, outBlob)); @@ -506,7 +635,8 @@ SlangResult Session::saveCoreModule(SlangArchiveType archiveType, ISlangBlob** o SlangResult Session::_readBuiltinModule( ISlangFileSystem* fileSystem, Scope* scope, - String moduleName) + String moduleName, + Module*& outModule) { // Get the name of the module StringBuilder moduleFilename; @@ -590,9 +720,7 @@ SlangResult Session::_readBuiltinModule( scope->nextSibling = subScope; } - // We need to retain this AST so that we can use it in other code - // (Note that the `Scope` type does not retain the AST it points to) - coreModules.add(module); + outModule = module.get(); } return SLANG_OK; @@ -2169,7 +2297,9 @@ Scope* TranslationUnitRequest::getLanguageScope() case SourceLanguage::HLSL: languageScope = getSession()->hlslLanguageScope; break; - + case SourceLanguage::GLSL: + languageScope = getSession()->glslLanguageScope; + break; case SourceLanguage::Slang: default: languageScope = getSession()->slangLanguageScope; @@ -3136,7 +3266,9 @@ void FrontEndCompileRequest::parseTranslationUnit(TranslationUnitRequest* transl case SourceLanguage::HLSL: languageScope = getSession()->hlslLanguageScope; break; - + case SourceLanguage::GLSL: + languageScope = getSession()->glslLanguageScope; + break; case SourceLanguage::Slang: default: languageScope = getSession()->slangLanguageScope; @@ -4132,6 +4264,16 @@ RefPtr<Module> Linkage::findOrImportModule( return previouslyLoadedModule; } + if (name == getSessionImpl()->glslModuleName) + { + // This is a builtin glsl module, just load it from embedded definition. + auto glslModule = getSessionImpl()->getBuiltinModule(slang::BuiltinModuleName::GLSL); + if (!glslModule) + { + sink->diagnose(loc, Diagnostics::glslModuleNotAvailable, name); + } + return glslModule; + } // Next, try to find the file of the given name, // using our ordinary include-handling logic. @@ -4168,17 +4310,7 @@ RefPtr<Module> Linkage::findOrImportModule( if (SLANG_FAILED( includeSystem.findFile(fileName, pathIncludedFromInfo.foundPath, filePathInfo))) { - if (name && name->text == "glsl") - { - // This is a builtin glsl module, just load it from embedded definition. - fileContents = getSessionImpl()->getGLSLLibraryCode(); - filePathInfo = PathInfo::makeFromString("glsl"); - checkBinaryModule = 0; - } - else - { - continue; - } + continue; } // Maybe this was loaded previously at a different relative name? @@ -6088,7 +6220,11 @@ RefPtr<Module> findOrImportModule( return linkage->findOrImportModule(name, loc, sink, loadedModules); } -void Session::addBuiltinSource(Scope* scope, String const& path, ISlangBlob* sourceBlob) +void Session::addBuiltinSource( + Scope* scope, + String const& path, + ISlangBlob* sourceBlob, + Module*& outModule) { SourceManager* sourceManager = getBuiltinSourceManager(); @@ -6151,9 +6287,7 @@ void Session::addBuiltinSource(Scope* scope, String const& path, ISlangBlob* sou scope->nextSibling = subScope; } - // We need to retain this AST so that we can use it in other code - // (Note that the `Scope` type does not retain the AST it points to) - coreModules.add(module); + outModule = module; } Session::~Session() diff --git a/source/slangc/main.cpp b/source/slangc/main.cpp index 2090b0412..718de6968 100644 --- a/source/slangc/main.cpp +++ b/source/slangc/main.cpp @@ -100,7 +100,9 @@ SLANG_TEST_TOOL_API SlangResult innerMain( else if (!session) { // Just create the global session in the regular way if there isn't one set - SLANG_RETURN_ON_FAIL(slang_createGlobalSession(SLANG_API_VERSION, session.writeRef())); + SlangGlobalSessionDesc desc = {}; + desc.enableGLSL = true; + SLANG_RETURN_ON_FAIL(slang_createGlobalSession2(&desc, session.writeRef())); } if (!shouldEmbedPrelude(argv, argc)) diff --git a/tools/slang-test/test-context.cpp b/tools/slang-test/test-context.cpp index bb9870dad..685ee1f2e 100644 --- a/tools/slang-test/test-context.cpp +++ b/tools/slang-test/test-context.cpp @@ -85,7 +85,10 @@ SlangResult TestContext::locateFileCheck() Result TestContext::init(const char* inExePath) { - m_session = spCreateSession(nullptr); + SlangGlobalSessionDesc desc = {}; + desc.enableGLSL = true; + slang_createGlobalSession2(&desc, &m_session); + if (!m_session) { return SLANG_FAIL; diff --git a/tools/slang-unit-test/unit-test-glsl-compile.cpp b/tools/slang-unit-test/unit-test-glsl-compile.cpp index 5a49da91b..288764295 100644 --- a/tools/slang-unit-test/unit-test-glsl-compile.cpp +++ b/tools/slang-unit-test/unit-test-glsl-compile.cpp @@ -26,7 +26,9 @@ SLANG_UNIT_TEST(glslCompile) } )"; ComPtr<slang::IGlobalSession> globalSession; - SLANG_CHECK(slang_createGlobalSession(SLANG_API_VERSION, globalSession.writeRef()) == SLANG_OK); + SlangGlobalSessionDesc globalDesc = {}; + globalDesc.enableGLSL = true; + SLANG_CHECK(slang_createGlobalSession2(&globalDesc, globalSession.writeRef()) == SLANG_OK); slang::TargetDesc targetDesc = {}; targetDesc.format = SLANG_SPIRV; targetDesc.profile = globalSession->findProfile("spirv_1_5"); diff --git a/tools/test-server/test-server-main.cpp b/tools/test-server/test-server-main.cpp index 1f1fbd066..633a23d7e 100644 --- a/tools/test-server/test-server-main.cpp +++ b/tools/test-server/test-server-main.cpp @@ -220,7 +220,9 @@ slang::IGlobalSession* TestServer::getOrCreateGlobalSession() if (!m_session) { // Just create the global session in the regular way if there isn't one set - if (SLANG_FAILED(slang_createGlobalSession(SLANG_API_VERSION, m_session.writeRef()))) + SlangGlobalSessionDesc desc = {}; + desc.enableGLSL = true; + if (SLANG_FAILED(slang_createGlobalSession2(&desc, m_session.writeRef()))) { return nullptr; } |