Replace stdlib on Slang API with CoreModule (#5405)

This is a breaking change in a way that the Slang API function names are changed. All of them are commented as "experimental" and we wouldn't provide a back-ward compatibility for them.

Following functions are renamed:

compileStdLib() -> compileCoreModule()
loadStdLib() -> loadCoreModule()
saveStdLib() -> saveCoreModule()
slang_createGlobalSessionWithoutStdLib() -> slang_createGlobalSessionWithoutCoreModule()
slang_getEmbeddedStdLib() -> slang_getEmbeddedCoreModule()
hasDeferredStdLib() -> hasDeferredCoreModule()
Following command-line arguments are renamed:

"-load-stdlib" -> "-load-core-module"
"-save-stdlib" -> "-save-core-module"
"-save-stdlib-bin-source" -> "-save-core-module-bin-source"
"-compile-stdlib" -> "-compile-core-module"

11 files changed, 69 insertions, 69 deletions

diff --git a/source/slang-record-replay/record/slang-global-session.cpp b/source/slang-record-replay/record/slang-global-session.cpp
index 012900f5c..06bbed553 100644
--- a/source/slang-record-replay/record/slang-global-session.cpp
+++ b/source/slang-record-replay/record/slang-global-session.cpp
@@ -306,48 +306,48 @@ namespace SlangRecord
         return res;
     }
 
-    SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::compileStdLib(slang::CompileStdLibFlags flags)
+    SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::compileCoreModule(slang::CompileCoreModuleFlags flags)
     {
         slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__);
 
         ParameterRecorder* recorder {};
         {
-            recorder = m_recordManager->beginMethodRecord(ApiCallId::IGlobalSession_compileStdLib, m_globalSessionHandle);
+            recorder = m_recordManager->beginMethodRecord(ApiCallId::IGlobalSession_compileCoreModule, m_globalSessionHandle);
             recorder->recordEnumValue(flags);
             m_recordManager->endMethodRecord();
         }
 
-        SlangResult res = m_actualGlobalSession->compileStdLib(flags);
+        SlangResult res = m_actualGlobalSession->compileCoreModule(flags);
         return res;
     }
 
-    SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::loadStdLib(const void* stdLib, size_t stdLibSizeInBytes)
+    SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::loadCoreModule(const void* coreModule, size_t coreModuleSizeInBytes)
     {
         slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__);
 
         ParameterRecorder* recorder {};
         {
-            recorder = m_recordManager->beginMethodRecord(ApiCallId::IGlobalSession_loadStdLib, m_globalSessionHandle);
-            recorder->recordPointer(stdLib, false, stdLibSizeInBytes);
+            recorder = m_recordManager->beginMethodRecord(ApiCallId::IGlobalSession_loadCoreModule, m_globalSessionHandle);
+            recorder->recordPointer(coreModule, false, coreModuleSizeInBytes);
             m_recordManager->endMethodRecord();
         }
 
-        SlangResult res = m_actualGlobalSession->loadStdLib(stdLib, stdLibSizeInBytes);
+        SlangResult res = m_actualGlobalSession->loadCoreModule(coreModule, coreModuleSizeInBytes);
         return res;
     }
 
-    SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::saveStdLib(SlangArchiveType archiveType, ISlangBlob** outBlob)
+    SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob)
     {
         slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__);
 
         ParameterRecorder* recorder {};
         {
-            recorder = m_recordManager->beginMethodRecord(ApiCallId::IGlobalSession_saveStdLib, m_globalSessionHandle);
+            recorder = m_recordManager->beginMethodRecord(ApiCallId::IGlobalSession_saveCoreModule, m_globalSessionHandle);
             recorder->recordEnumValue(archiveType);
             recorder = m_recordManager->endMethodRecord();
         }
 
-        SlangResult res = m_actualGlobalSession->saveStdLib(archiveType, outBlob);
+        SlangResult res = m_actualGlobalSession->saveCoreModule(archiveType, outBlob);
 
         {
             recorder->recordAddress(*outBlob);
diff --git a/source/slang-record-replay/record/slang-global-session.h b/source/slang-record-replay/record/slang-global-session.h
index 25504ff02..284185cb4 100644
--- a/source/slang-record-replay/record/slang-global-session.h
+++ b/source/slang-record-replay/record/slang-global-session.h
@@ -42,9 +42,9 @@ namespace SlangRecord
             SLANG_NO_THROW SlangResult SLANG_MCALL checkCompileTargetSupport(SlangCompileTarget target) override;
             SLANG_NO_THROW SlangResult SLANG_MCALL checkPassThroughSupport(SlangPassThrough passThrough) override;
 
-            SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib(slang::CompileStdLibFlags flags) override;
-            SLANG_NO_THROW SlangResult SLANG_MCALL loadStdLib(const void* stdLib, size_t stdLibSizeInBytes) override;
-            SLANG_NO_THROW SlangResult SLANG_MCALL saveStdLib(SlangArchiveType archiveType, ISlangBlob** outBlob) override;
+            SLANG_NO_THROW SlangResult SLANG_MCALL compileCoreModule(slang::CompileCoreModuleFlags flags) override;
+            SLANG_NO_THROW SlangResult SLANG_MCALL loadCoreModule(const void* coreModule, size_t coreModuleSizeInBytes) override;
+            SLANG_NO_THROW SlangResult SLANG_MCALL saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob) override;
 
             SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(char const* name) override;
 
diff --git a/source/slang-record-replay/replay/decoder-consumer.h b/source/slang-record-replay/replay/decoder-consumer.h
index aa3883cc0..d1039d867 100644
--- a/source/slang-record-replay/replay/decoder-consumer.h
+++ b/source/slang-record-replay/replay/decoder-consumer.h
@@ -30,9 +30,9 @@ namespace SlangRecord
         virtual void IGlobalSession_getSharedLibraryLoader(ObjectID objectId, ObjectID outLoaderId) = 0;
         virtual void IGlobalSession_checkCompileTargetSupport(ObjectID objectId, SlangCompileTarget target) = 0;
         virtual void IGlobalSession_checkPassThroughSupport(ObjectID objectId, SlangPassThrough passThrough) = 0;
-        virtual void IGlobalSession_compileStdLib(ObjectID objectId, slang::CompileStdLibFlags flags) = 0;
-        virtual void IGlobalSession_loadStdLib(ObjectID objectId, const void* stdLib, size_t stdLibSizeInBytes) = 0;
-        virtual void IGlobalSession_saveStdLib(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId) = 0;
+        virtual void IGlobalSession_compileCoreModule(ObjectID objectId, slang::CompileCoreModuleFlags flags) = 0;
+        virtual void IGlobalSession_loadCoreModule(ObjectID objectId, const void* coreModule, size_t coreModuleSizeInBytes) = 0;
+        virtual void IGlobalSession_saveCoreModule(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId) = 0;
         virtual void IGlobalSession_findCapability(ObjectID objectId, char const* name) = 0;
         virtual void IGlobalSession_setDownstreamCompilerForTransition(ObjectID objectId, SlangCompileTarget source, SlangCompileTarget target, SlangPassThrough compiler) = 0;
         virtual void IGlobalSession_getDownstreamCompilerForTransition(ObjectID objectId, SlangCompileTarget source, SlangCompileTarget target) = 0;
diff --git a/source/slang-record-replay/replay/json-consumer.cpp b/source/slang-record-replay/replay/json-consumer.cpp
index 27b2830d6..21fd45807 100644
--- a/source/slang-record-replay/replay/json-consumer.cpp
+++ b/source/slang-record-replay/replay/json-consumer.cpp
@@ -787,17 +787,17 @@ namespace SlangRecord
     }
 
 
-    void JsonConsumer::IGlobalSession_compileStdLib(ObjectID objectId, slang::CompileStdLibFlags flags)
+    void JsonConsumer::IGlobalSession_compileCoreModule(ObjectID objectId, slang::CompileCoreModuleFlags flags)
     {
         SANITY_CHECK();
         Slang::StringBuilder builder;
         int indent = 0;
 
         {
-            ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::compileStdLib");
+            ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::compileCoreModule");
             {
                 _writePair(builder, indent, "this", Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
-                _writePairNoComma(builder, indent, "flags", CompileStdLibFlagsToString(flags));
+                _writePairNoComma(builder, indent, "flags", CompileCoreModuleFlagsToString(flags));
             }
         }
 
@@ -806,19 +806,19 @@ namespace SlangRecord
     }
 
 
-    void JsonConsumer::IGlobalSession_loadStdLib(ObjectID objectId, const void* stdLib, size_t stdLibSizeInBytes)
+    void JsonConsumer::IGlobalSession_loadCoreModule(ObjectID objectId, const void* coreModule, size_t coreModuleSizeInBytes)
     {
         SANITY_CHECK();
         Slang::StringBuilder builder;
         int indent = 0;
-        _writeString(builder, indent, "IGlobalSession::loadStdLib: {\n");
+        _writeString(builder, indent, "IGlobalSession::loadCoreModule: {\n");
 
         {
-            ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::loadStdLib");
+            ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::loadCoreModule");
             {
                 _writePair(builder, indent, "this", Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
-                _writePair(builder, indent, "stdLib-Ignore-Data", Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
-                _writePairNoComma(builder, indent, "stdLibSizeInBytes", (uint32_t)stdLibSizeInBytes);
+                _writePair(builder, indent, "coreModule-Ignore-Data", Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
+                _writePairNoComma(builder, indent, "coreModuleSizeInBytes", (uint32_t)coreModuleSizeInBytes);
             }
         }
 
@@ -826,14 +826,14 @@ namespace SlangRecord
         m_fileStream.flush();
     }
 
-    void JsonConsumer::IGlobalSession_saveStdLib(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId)
+    void JsonConsumer::IGlobalSession_saveCoreModule(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId)
     {
         SANITY_CHECK();
         Slang::StringBuilder builder;
         int indent = 0;
 
         {
-            ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::saveStdLib");
+            ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::saveCoreModule");
             {
                 _writePair(builder, indent, "this", Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
                 _writePair(builder, indent, "archiveType", SlangArchiveTypeToString(archiveType));
diff --git a/source/slang-record-replay/replay/json-consumer.h b/source/slang-record-replay/replay/json-consumer.h
index d0529aab4..a7eaf1ec2 100644
--- a/source/slang-record-replay/replay/json-consumer.h
+++ b/source/slang-record-replay/replay/json-consumer.h
@@ -77,9 +77,9 @@ namespace SlangRecord
         virtual void IGlobalSession_getSharedLibraryLoader(ObjectID objectId, ObjectID outLoaderId);
         virtual void IGlobalSession_checkCompileTargetSupport(ObjectID objectId, SlangCompileTarget target);
         virtual void IGlobalSession_checkPassThroughSupport(ObjectID objectId, SlangPassThrough passThrough);
-        virtual void IGlobalSession_compileStdLib(ObjectID objectId, slang::CompileStdLibFlags flags);
-        virtual void IGlobalSession_loadStdLib(ObjectID objectId, const void* stdLib, size_t stdLibSizeInBytes);
-        virtual void IGlobalSession_saveStdLib(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId);
+        virtual void IGlobalSession_compileCoreModule(ObjectID objectId, slang::CompileCoreModuleFlags flags);
+        virtual void IGlobalSession_loadCoreModule(ObjectID objectId, const void* coreModule, size_t coreModuleSizeInBytes);
+        virtual void IGlobalSession_saveCoreModule(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId);
         virtual void IGlobalSession_findCapability(ObjectID objectId, char const* name);
         virtual void IGlobalSession_setDownstreamCompilerForTransition(ObjectID objectId, SlangCompileTarget source, SlangCompileTarget target, SlangPassThrough compiler);
         virtual void IGlobalSession_getDownstreamCompilerForTransition(ObjectID objectId, SlangCompileTarget source, SlangCompileTarget target);
diff --git a/source/slang-record-replay/replay/replay-consumer.cpp b/source/slang-record-replay/replay/replay-consumer.cpp
index dd457c5d0..3ef2ae97d 100644
--- a/source/slang-record-replay/replay/replay-consumer.cpp
+++ b/source/slang-record-replay/replay/replay-consumer.cpp
@@ -466,42 +466,42 @@ namespace SlangRecord
     }
 
 
-    void ReplayConsumer::IGlobalSession_compileStdLib(ObjectID objectId, slang::CompileStdLibFlags flags)
+    void ReplayConsumer::IGlobalSession_compileCoreModule(ObjectID objectId, slang::CompileCoreModuleFlags flags)
     {
         InputObjectSanityCheck(objectId);
 
         slang::IGlobalSession* globalSession = getObjectPointer<slang::IGlobalSession>(objectId);
-        SlangResult res = globalSession->compileStdLib(flags);
+        SlangResult res = globalSession->compileCoreModule(flags);
 
         if (SLANG_FAILED(res))
         {
-            slangRecordLog(LogLevel::Error, "IGlobalSession::compileStdLib fails, ret: 0x%X, this: 0x%X\n", res, objectId);
+            slangRecordLog(LogLevel::Error, "IGlobalSession::compileCoreModule fails, ret: 0x%X, this: 0x%X\n", res, objectId);
         }
     }
 
 
-    void ReplayConsumer::IGlobalSession_loadStdLib(ObjectID objectId, const void* stdLib, size_t stdLibSizeInBytes)
+    void ReplayConsumer::IGlobalSession_loadCoreModule(ObjectID objectId, const void* coreModule, size_t coreModuleSizeInBytes)
     {
         InputObjectSanityCheck(objectId);
 
         slang::IGlobalSession* globalSession = getObjectPointer<slang::IGlobalSession>(objectId);
-        SlangResult res = globalSession->loadStdLib(stdLib, stdLibSizeInBytes);
+        SlangResult res = globalSession->loadCoreModule(coreModule, coreModuleSizeInBytes);
 
         if (SLANG_FAILED(res))
         {
-            slangRecordLog(LogLevel::Error, "IGlobalSession::loadStdLib fails, ret: 0x%X, this: 0x%X\n", res, objectId);
+            slangRecordLog(LogLevel::Error, "IGlobalSession::loadCoreModule fails, ret: 0x%X, this: 0x%X\n", res, objectId);
         }
     }
 
 
-    void ReplayConsumer::IGlobalSession_saveStdLib(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId)
+    void ReplayConsumer::IGlobalSession_saveCoreModule(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId)
     {
         InputObjectSanityCheck(objectId);
         OutputObjectSanityCheck(outBlobId);
 
         slang::IGlobalSession* globalSession = getObjectPointer<slang::IGlobalSession>(objectId);
         ISlangBlob* outBlob {};
-        SlangResult res = globalSession->saveStdLib(archiveType, &outBlob);
+        SlangResult res = globalSession->saveCoreModule(archiveType, &outBlob);
 
         if (outBlob && SLANG_SUCCEEDED(res))
         {
@@ -509,7 +509,7 @@ namespace SlangRecord
         }
         else
         {
-            slangRecordLog(LogLevel::Error, "IGlobalSession::saveStdLib fails, ret: 0x%X, this: 0x%X\n", res, objectId);
+            slangRecordLog(LogLevel::Error, "IGlobalSession::saveCoreModule fails, ret: 0x%X, this: 0x%X\n", res, objectId);
         }
     }
 
diff --git a/source/slang-record-replay/replay/replay-consumer.h b/source/slang-record-replay/replay/replay-consumer.h
index b7620af0d..8a0260c82 100644
--- a/source/slang-record-replay/replay/replay-consumer.h
+++ b/source/slang-record-replay/replay/replay-consumer.h
@@ -76,9 +76,9 @@ namespace SlangRecord
         virtual void IGlobalSession_getSharedLibraryLoader(ObjectID objectId, ObjectID outLoaderId) override;
         virtual void IGlobalSession_checkCompileTargetSupport(ObjectID objectId, SlangCompileTarget target) override;
         virtual void IGlobalSession_checkPassThroughSupport(ObjectID objectId, SlangPassThrough passThrough) override;
-        virtual void IGlobalSession_compileStdLib(ObjectID objectId, slang::CompileStdLibFlags flags) override;
-        virtual void IGlobalSession_loadStdLib(ObjectID objectId, const void* stdLib, size_t stdLibSizeInBytes) override;
-        virtual void IGlobalSession_saveStdLib(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId) override;
+        virtual void IGlobalSession_compileCoreModule(ObjectID objectId, slang::CompileCoreModuleFlags flags) override;
+        virtual void IGlobalSession_loadCoreModule(ObjectID objectId, const void* coreModule, size_t coreModuleSizeInBytes) override;
+        virtual void IGlobalSession_saveCoreModule(ObjectID objectId, SlangArchiveType archiveType, ObjectID outBlobId) override;
         virtual void IGlobalSession_findCapability(ObjectID objectId, char const* name) override;
         virtual void IGlobalSession_setDownstreamCompilerForTransition(ObjectID objectId, SlangCompileTarget source, SlangCompileTarget target, SlangPassThrough compiler) override;
         virtual void IGlobalSession_getDownstreamCompilerForTransition(ObjectID objectId, SlangCompileTarget source, SlangCompileTarget target) override;
diff --git a/source/slang-record-replay/replay/slang-decoder.cpp b/source/slang-record-replay/replay/slang-decoder.cpp
index 30d182729..6eb4ac8f5 100644
--- a/source/slang-record-replay/replay/slang-decoder.cpp
+++ b/source/slang-record-replay/replay/slang-decoder.cpp
@@ -91,14 +91,14 @@ namespace SlangRecord
         case ApiCallId::IGlobalSession_checkPassThroughSupport:
             IGlobalSession_checkPassThroughSupport(objectId, parameterBlock);
             break;
-        case ApiCallId::IGlobalSession_compileStdLib:
-            IGlobalSession_compileStdLib(objectId, parameterBlock);
+        case ApiCallId::IGlobalSession_compileCoreModule:
+            IGlobalSession_compileCoreModule(objectId, parameterBlock);
             break;
-        case ApiCallId::IGlobalSession_loadStdLib:
-            IGlobalSession_loadStdLib(objectId, parameterBlock);
+        case ApiCallId::IGlobalSession_loadCoreModule:
+            IGlobalSession_loadCoreModule(objectId, parameterBlock);
             break;
-        case ApiCallId::IGlobalSession_saveStdLib:
-            IGlobalSession_saveStdLib(objectId, parameterBlock);
+        case ApiCallId::IGlobalSession_saveCoreModule:
+            IGlobalSession_saveCoreModule(objectId, parameterBlock);
             break;
         case ApiCallId::IGlobalSession_findCapability:
             IGlobalSession_findCapability(objectId, parameterBlock);
@@ -619,29 +619,29 @@ namespace SlangRecord
         slangRecordLog(LogLevel::Debug, "%s should not be called, it'a not recordd\n", __PRETTY_FUNCTION__);
     }
 
-    void SlangDecoder::IGlobalSession_compileStdLib(ObjectID objectId, ParameterBlock const& parameterBlock)
+    void SlangDecoder::IGlobalSession_compileCoreModule(ObjectID objectId, ParameterBlock const& parameterBlock)
     {
-        slang::CompileStdLibFlags flags {};
+        slang::CompileCoreModuleFlags flags {};
         ParameterDecoder::decodeEnumValue(parameterBlock.parameterBuffer, parameterBlock.parameterBufferSize, flags);
 
         for (auto consumer: m_consumers)
         {
-            consumer->IGlobalSession_compileStdLib(objectId, flags);
+            consumer->IGlobalSession_compileCoreModule(objectId, flags);
         }
     }
 
-    void SlangDecoder::IGlobalSession_loadStdLib(ObjectID objectId, ParameterBlock const& parameterBlock)
+    void SlangDecoder::IGlobalSession_loadCoreModule(ObjectID objectId, ParameterBlock const& parameterBlock)
     {
-        PointerDecoder<void*> stdLib;
-        ParameterDecoder::decodePointer(parameterBlock.parameterBuffer, parameterBlock.parameterBufferSize, stdLib);
+        PointerDecoder<void*> coreModule;
+        ParameterDecoder::decodePointer(parameterBlock.parameterBuffer, parameterBlock.parameterBufferSize, coreModule);
 
         for (auto consumer: m_consumers)
         {
-            consumer->IGlobalSession_loadStdLib(objectId, stdLib.getPointer(), stdLib.getDataSize());
+            consumer->IGlobalSession_loadCoreModule(objectId, coreModule.getPointer(), coreModule.getDataSize());
         }
     }
 
-    void SlangDecoder::IGlobalSession_saveStdLib(ObjectID objectId, ParameterBlock const& parameterBlock)
+    void SlangDecoder::IGlobalSession_saveCoreModule(ObjectID objectId, ParameterBlock const& parameterBlock)
     {
         SlangArchiveType archiveType {};
         ObjectID outBlobId = 0;
@@ -650,7 +650,7 @@ namespace SlangRecord
 
         for (auto consumer: m_consumers)
         {
-            consumer->IGlobalSession_saveStdLib(objectId, archiveType, outBlobId);
+            consumer->IGlobalSession_saveCoreModule(objectId, archiveType, outBlobId);
         }
     }
 
diff --git a/source/slang-record-replay/replay/slang-decoder.h b/source/slang-record-replay/replay/slang-decoder.h
index 78c3128ba..03af6d842 100644
--- a/source/slang-record-replay/replay/slang-decoder.h
+++ b/source/slang-record-replay/replay/slang-decoder.h
@@ -57,9 +57,9 @@ namespace SlangRecord
 		void IGlobalSession_getSharedLibraryLoader(ObjectID objectId, ParameterBlock const& parameterBlock);
 		void IGlobalSession_checkCompileTargetSupport(ObjectID objectId, ParameterBlock const& parameterBlock);
 		void IGlobalSession_checkPassThroughSupport(ObjectID objectId, ParameterBlock const& parameterBlock);
-		void IGlobalSession_compileStdLib(ObjectID objectId, ParameterBlock const& parameterBlock);
-		void IGlobalSession_loadStdLib(ObjectID objectId, ParameterBlock const& parameterBlock);
-		void IGlobalSession_saveStdLib(ObjectID objectId, ParameterBlock const& parameterBlock);
+		void IGlobalSession_compileCoreModule(ObjectID objectId, ParameterBlock const& parameterBlock);
+		void IGlobalSession_loadCoreModule(ObjectID objectId, ParameterBlock const& parameterBlock);
+		void IGlobalSession_saveCoreModule(ObjectID objectId, ParameterBlock const& parameterBlock);
 		void IGlobalSession_findCapability(ObjectID objectId, ParameterBlock const& parameterBlock);
 		void IGlobalSession_setDownstreamCompilerForTransition(ObjectID objectId, ParameterBlock const& parameterBlock);
 		void IGlobalSession_getDownstreamCompilerForTransition(ObjectID objectId, ParameterBlock const& parameterBlock);
diff --git a/source/slang-record-replay/util/emum-to-string.h b/source/slang-record-replay/util/emum-to-string.h
index 8c140cf3d..3b275399c 100644
--- a/source/slang-record-replay/util/emum-to-string.h
+++ b/source/slang-record-replay/util/emum-to-string.h
@@ -215,13 +215,13 @@ namespace SlangRecord
         CASE(ValidateUniformity);
         CASE(AllowGLSL);
         CASE(ArchiveType);
-        CASE(CompileStdLib);
+        CASE(CompileCoreModule);
         CASE(Doc);
         CASE(IrCompression);
-        CASE(LoadStdLib);
+        CASE(LoadCoreModule);
         CASE(ReferenceModule);
-        CASE(SaveStdLib);
-        CASE(SaveStdLibBinSource);
+        CASE(SaveCoreModule);
+        CASE(SaveCoreModuleBinSource);
         CASE(TrackLiveness);
         CASE(LoopInversion);
         CASE(CountOfParsableOptions);
@@ -332,15 +332,15 @@ namespace SlangRecord
         }
     }
 
-    static Slang::String CompileStdLibFlagsToString(const slang::CompileStdLibFlags flags)
+    static Slang::String CompileCoreModuleFlagsToString(const slang::CompileCoreModuleFlags flags)
     {
         using namespace slang;
         switch(flags)
         {
-        case CompileStdLibFlag::WriteDocumentation: return "WriteDocumentation";
+        case CompileCoreModuleFlag::WriteDocumentation: return "WriteDocumentation";
         default:
             Slang::StringBuilder str;
-            str << "Unknown CompileStdLibFlags: " << static_cast<uint32_t>(flags);
+            str << "Unknown CompileCoreModuleFlags: " << static_cast<uint32_t>(flags);
             return str.toString();
         }
     }
diff --git a/source/slang-record-replay/util/record-format.h b/source/slang-record-replay/util/record-format.h
index 1a32dbbd6..7c53044d6 100644
--- a/source/slang-record-replay/util/record-format.h
+++ b/source/slang-record-replay/util/record-format.h
@@ -78,9 +78,9 @@ namespace SlangRecord
         IGlobalSession_getSharedLibraryLoader                = makeApiCallId(Class_IGlobalSession, 0x000E),
         IGlobalSession_checkCompileTargetSupport             = makeApiCallId(Class_IGlobalSession, 0x000F),
         IGlobalSession_checkPassThroughSupport               = makeApiCallId(Class_IGlobalSession, 0x0010),
-        IGlobalSession_compileStdLib                         = makeApiCallId(Class_IGlobalSession, 0x0011),
-        IGlobalSession_loadStdLib                            = makeApiCallId(Class_IGlobalSession, 0x0012),
-        IGlobalSession_saveStdLib                            = makeApiCallId(Class_IGlobalSession, 0x0013),
+        IGlobalSession_compileCoreModule                     = makeApiCallId(Class_IGlobalSession, 0x0011),
+        IGlobalSession_loadCoreModule                        = makeApiCallId(Class_IGlobalSession, 0x0012),
+        IGlobalSession_saveCoreModule                        = makeApiCallId(Class_IGlobalSession, 0x0013),
         IGlobalSession_findCapability                        = makeApiCallId(Class_IGlobalSession, 0x0014),
         IGlobalSession_setDownstreamCompilerForTransition    = makeApiCallId(Class_IGlobalSession, 0x0015),
         IGlobalSession_getDownstreamCompilerForTransition    = makeApiCallId(Class_IGlobalSession, 0x0016),