summaryrefslogtreecommitdiff
path: root/source/slang
diff options
context:
space:
mode:
Diffstat (limited to 'source/slang')
-rw-r--r--source/slang/slang-compiler.h13
-rw-r--r--source/slang/slang-file-system.cpp2
-rw-r--r--source/slang/slang-ir-serialize.cpp42
-rw-r--r--source/slang/slang-options.cpp2
-rw-r--r--source/slang/slang-state-serialize.cpp102
-rw-r--r--source/slang/slang-state-serialize.h8
-rw-r--r--source/slang/slang.cpp65
7 files changed, 169 insertions, 65 deletions
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
index 9b361064d..1e1f166de 100644
--- a/source/slang/slang-compiler.h
+++ b/source/slang/slang-compiler.h
@@ -1172,17 +1172,19 @@ namespace Slang
/// If this member is `null`, a default implementation that tries
/// to use the native OS filesystem will be used instead.
///
- ComPtr<ISlangFileSystem> fileSystem;
+ ComPtr<ISlangFileSystem> m_fileSystem;
/// The extended file system implementation. Will be set to a default implementation
/// if fileSystem is nullptr. Otherwise it will either be fileSystem's interface,
/// or a wrapped impl that makes fileSystem operate as fileSystemExt
- ComPtr<ISlangFileSystemExt> fileSystemExt;
+ ComPtr<ISlangFileSystemExt> m_fileSystemExt;
+
/// Set if fileSystemExt is a cache file system
- RefPtr<CacheFileSystem> cacheFileSystem;
+ RefPtr<CacheFileSystem> m_cacheFileSystem;
- ISlangFileSystemExt* getFileSystemExt() { return fileSystemExt; }
+ ISlangFileSystemExt* getFileSystemExt() { return m_fileSystemExt; }
+ CacheFileSystem* getCacheFileSystem() const { return m_cacheFileSystem; }
/// Load a file into memory using the configured file system.
///
@@ -1192,7 +1194,6 @@ namespace Slang
///
SlangResult loadFile(String const& path, PathInfo& outPathInfo, ISlangBlob** outBlob);
-
RefPtr<Expr> parseTypeString(String typeStr, RefPtr<Scope> scope);
Type* specializeType(
@@ -1230,7 +1231,7 @@ namespace Slang
return m_sourceManager;
}
- /// Override the source manager for the linakge.
+ /// Override the source manager for the linkage.
///
/// This is only used to install a temporary override when
/// parsing stuff from strings (where we don't want to retain
diff --git a/source/slang/slang-file-system.cpp b/source/slang/slang-file-system.cpp
index 4ee961df5..7d6d6df66 100644
--- a/source/slang/slang-file-system.cpp
+++ b/source/slang/slang-file-system.cpp
@@ -138,7 +138,7 @@ SLANG_NO_THROW SlangResult SLANG_MCALL OSFileSystemExt::saveFile(const char* pat
{
FileStream stream(pathIn, FileMode::Create, FileAccess::Write, FileShare::ReadWrite);
- int64_t numWritten = stream.Write(data, size);
+ int64_t numWritten = stream.write(data, size);
if (numWritten != int64_t(size))
{
diff --git a/source/slang/slang-ir-serialize.cpp b/source/slang/slang-ir-serialize.cpp
index 02ed3142d..c82592527 100644
--- a/source/slang/slang-ir-serialize.cpp
+++ b/source/slang/slang-ir-serialize.cpp
@@ -847,9 +847,9 @@ static Result _writeArrayChunk(IRSerialBinary::CompressionType compressionType,
header.m_chunk.m_size = uint32_t(payloadSize);
header.m_numEntries = uint32_t(numEntries);
- stream->Write(&header, sizeof(header));
+ stream->write(&header, sizeof(header));
- stream->Write(data, typeSize * numEntries);
+ stream->write(data, typeSize * numEntries);
break;
}
case Bin::CompressionType::VariableByteLite:
@@ -868,9 +868,9 @@ static Result _writeArrayChunk(IRSerialBinary::CompressionType compressionType,
header.m_numEntries = uint32_t(numEntries);
header.m_numCompressedEntries = uint32_t(numCompressedEntries);
- stream->Write(&header, sizeof(header));
+ stream->write(&header, sizeof(header));
- stream->Write(compressedPayload.begin(), compressedPayload.getCount());
+ stream->write(compressedPayload.begin(), compressedPayload.getCount());
break;
}
default:
@@ -884,7 +884,7 @@ static Result _writeArrayChunk(IRSerialBinary::CompressionType compressionType,
const uint8_t pad[4] = { 0, 0, 0, 0 };
// Pad outs
int padSize = 4 - (payloadSize & 3);
- stream->Write(pad, padSize);
+ stream->write(pad, padSize);
}
return SLANG_OK;
@@ -1013,8 +1013,8 @@ Result _writeInstArrayChunk(IRSerialBinary::CompressionType compressionType, uin
header.m_numEntries = uint32_t(array.getCount());
header.m_numCompressedEntries = 0;
- stream->Write(&header, sizeof(header));
- stream->Write(compressedPayload.begin(), compressedPayload.getCount());
+ stream->write(&header, sizeof(header));
+ stream->write(compressedPayload.begin(), compressedPayload.getCount());
// All chunks have sizes rounded to dword size
if (payloadSize & 3)
@@ -1022,7 +1022,7 @@ Result _writeInstArrayChunk(IRSerialBinary::CompressionType compressionType, uin
const uint8_t pad[4] = { 0, 0, 0, 0 };
// Pad outs
int padSize = 4 - (payloadSize & 3);
- stream->Write(pad, padSize);
+ stream->write(pad, padSize);
}
return SLANG_OK;
}
@@ -1128,7 +1128,7 @@ static size_t _calcInstChunkSize(IRSerialBinary::CompressionType compressionType
riffHeader.m_type = Bin::kRiffFourCc;
riffHeader.m_size = uint32_t(totalSize);
- stream->Write(&riffHeader, sizeof(riffHeader));
+ stream->write(&riffHeader, sizeof(riffHeader));
}
{
Bin::SlangHeader slangHeader;
@@ -1136,7 +1136,7 @@ static size_t _calcInstChunkSize(IRSerialBinary::CompressionType compressionType
slangHeader.m_chunk.m_size = uint32_t(sizeof(slangHeader) - sizeof(RiffChunk));
slangHeader.m_compressionType = uint32_t(Bin::CompressionType::VariableByteLite);
- stream->Write(&slangHeader, sizeof(slangHeader));
+ stream->write(&slangHeader, sizeof(slangHeader));
}
SLANG_RETURN_ON_FAIL(_writeInstArrayChunk(compressionType, Bin::kInstFourCc, data.m_insts, stream));
@@ -1206,7 +1206,7 @@ static Result _readArrayChunk(IRSerialBinary::CompressionType compressionType, c
Bin::CompressedArrayHeader header;
header.m_chunk = chunk;
- stream->Read(&header.m_chunk + 1, sizeof(header) - sizeof(RiffChunk));
+ stream->read(&header.m_chunk + 1, sizeof(header) - sizeof(RiffChunk));
*numReadInOut += sizeof(header) - sizeof(RiffChunk);
void* data = listOut.setSize(header.m_numEntries);
@@ -1217,7 +1217,7 @@ static Result _readArrayChunk(IRSerialBinary::CompressionType compressionType, c
List<uint8_t> compressedPayload;
compressedPayload.setCount(payloadSize);
- stream->Read(compressedPayload.begin(), payloadSize);
+ stream->read(compressedPayload.begin(), payloadSize);
*numReadInOut += payloadSize;
SLANG_ASSERT(header.m_numCompressedEntries == uint32_t((header.m_numEntries * typeSize) / sizeof(uint32_t)));
@@ -1232,14 +1232,14 @@ static Result _readArrayChunk(IRSerialBinary::CompressionType compressionType, c
Bin::ArrayHeader header;
header.m_chunk = chunk;
- stream->Read(&header.m_chunk + 1, sizeof(header) - sizeof(RiffChunk));
+ stream->read(&header.m_chunk + 1, sizeof(header) - sizeof(RiffChunk));
*numReadInOut += sizeof(header) - sizeof(RiffChunk);
const size_t payloadSize = header.m_numEntries * typeSize;
void* data = listOut.setSize(header.m_numEntries);
- stream->Read(data, payloadSize);
+ stream->read(data, payloadSize);
*numReadInOut += payloadSize;
break;
}
@@ -1251,7 +1251,7 @@ static Result _readArrayChunk(IRSerialBinary::CompressionType compressionType, c
const uint8_t pad[4] = { 0, 0, 0, 0 };
// Pad outs
int padSize = 4 - int(*numReadInOut & 3);
- stream->Seek(SeekOrigin::Current, padSize);
+ stream->seek(SeekOrigin::Current, padSize);
*numReadInOut += padSize;
}
@@ -1374,7 +1374,7 @@ static Result _readInstArrayChunk(const IRSerialBinary::SlangHeader& slangHeader
Bin::CompressedArrayHeader header;
header.m_chunk = chunk;
- stream->Read(&header.m_chunk + 1, sizeof(header) - sizeof(RiffChunk));
+ stream->read(&header.m_chunk + 1, sizeof(header) - sizeof(RiffChunk));
*numReadInOut += sizeof(header) - sizeof(RiffChunk);
// Need to read all the compressed data...
@@ -1383,7 +1383,7 @@ static Result _readInstArrayChunk(const IRSerialBinary::SlangHeader& slangHeader
List<uint8_t> compressedPayload;
compressedPayload.setCount(payloadSize);
- stream->Read(compressedPayload.begin(), payloadSize);
+ stream->read(compressedPayload.begin(), payloadSize);
*numReadInOut += payloadSize;
arrayOut.setCount(header.m_numEntries);
@@ -1402,7 +1402,7 @@ static Result _readInstArrayChunk(const IRSerialBinary::SlangHeader& slangHeader
{
// Pad outs
int padSize = 4 - int(*numReadInOut & 3);
- stream->Seek(SeekOrigin::Current, padSize);
+ stream->seek(SeekOrigin::Current, padSize);
*numReadInOut += padSize;
}
@@ -1449,7 +1449,7 @@ static Result _readInstArrayChunk(const IRSerialBinary::SlangHeader& slangHeader
// NOTE! Really we should only read what we know the size to be...
// and skip if it's larger
- stream->Read(&slangHeader.m_chunk + 1, sizeof(slangHeader) - sizeof(chunk));
+ stream->read(&slangHeader.m_chunk + 1, sizeof(slangHeader) - sizeof(chunk));
remainingBytes -= RiffUtil::calcChunkTotalSize(chunk);
break;
@@ -1964,11 +1964,11 @@ static int _calcFixSourceLoc(const IRSerialData::DebugSourceInfo& info, SourceVi
}
// Write the data out to stream
- MemoryStream memoryStream(FileAccess::ReadWrite);
+ OwnedMemoryStream memoryStream(FileAccess::ReadWrite);
SLANG_RETURN_ON_FAIL(IRSerialWriter::writeStream(serialData, compressionType, &memoryStream));
// Reset stream
- memoryStream.Seek(SeekOrigin::Start, 0);
+ memoryStream.seek(SeekOrigin::Start, 0);
IRSerialData readData;
diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp
index 2e1b625d9..6b09179db 100644
--- a/source/slang/slang-options.cpp
+++ b/source/slang/slang-options.cpp
@@ -496,7 +496,7 @@ struct OptionsParser
else if (argStr == "-dump-repro")
{
SLANG_RETURN_ON_FAIL(tryReadCommandLineArgument(sink, arg, &argCursor, argEnd, requestImpl->dumpRepro));
- requestImpl->getLinkage()->setRequireCacheFileSystem(true);
+ spEnableReproCapture(asExternal(requestImpl));
}
else if (argStr == "-extract-repro")
{
diff --git a/source/slang/slang-state-serialize.cpp b/source/slang/slang-state-serialize.cpp
index b37529121..110ea52b2 100644
--- a/source/slang/slang-state-serialize.cpp
+++ b/source/slang/slang-state-serialize.cpp
@@ -318,15 +318,49 @@ static bool _isStorable(const PathInfo::Type type)
for (Index i = 0; i < linkage->targets.getCount(); ++i)
{
- auto& dst = dstTargets[i];
- TargetRequest* targetRequest = linkage->targets[i];
+ TargetRequest* srcTargetRequest = linkage->targets[i];
- dst.target = targetRequest->getTarget();
- dst.profile = targetRequest->getTargetProfile();
- dst.targetFlags = targetRequest->targetFlags;
- dst.floatingPointMode = targetRequest->floatingPointMode;
- }
+ // Copy the simple stuff
+ {
+ auto& dst = dstTargets[i];
+ dst.target = srcTargetRequest->getTarget();
+ dst.profile = srcTargetRequest->getTargetProfile();
+ dst.targetFlags = srcTargetRequest->targetFlags;
+ dst.floatingPointMode = srcTargetRequest->floatingPointMode;
+ }
+
+ // Copy the entry point/target output names
+ {
+ const auto& srcTargetInfos = request->targetInfos;
+
+ if (RefPtr<EndToEndCompileRequest::TargetInfo>* infosPtr = srcTargetInfos.TryGetValue(srcTargetRequest))
+ {
+ EndToEndCompileRequest::TargetInfo* infos = *infosPtr;
+
+ const auto& entryPointOutputPaths = infos->entryPointOutputPaths;
+
+ Safe32Array<OutputState> dstOutputStates;
+ dstOutputStates = inOutContainer.allocateArray<OutputState>(entryPointOutputPaths.Count());
+ Index index = 0;
+ for (const auto& pair : entryPointOutputPaths)
+ {
+ Safe32Ptr<RelativeString> outputPath = inOutContainer.newString(pair.Value.getUnownedSlice());
+
+ auto& dstOutputState = dstOutputStates[index];
+
+ dstOutputState.entryPointIndex = int32_t(pair.Key);
+ dstOutputState.outputPath = outputPath;
+
+ index++;
+ }
+
+ dstTargets[i].outputStates = dstOutputStates;
+ }
+ }
+ }
+
+ // Save the result
requestState->targetRequests = dstTargets;
}
@@ -383,7 +417,12 @@ static bool _isStorable(const PathInfo::Type type)
// Find files from the file system, and mapping paths to files
{
- CacheFileSystem* cacheFileSystem = linkage->cacheFileSystem;
+ CacheFileSystem* cacheFileSystem = linkage->getCacheFileSystem();
+ if (!cacheFileSystem)
+ {
+ return SLANG_FAIL;
+ }
+
// Traverse the references (in process we will construct the map from PathInfo)
{
const auto& srcFiles = cacheFileSystem->getPathMap();
@@ -651,8 +690,17 @@ static void _loadDefines(const Relative32Array<StateSerializeUtil::StringPair>&
{
auto externalRequest = asExternal(request);
+
auto linkage = request->getLinkage();
+ // TODO(JS): Really should be more exhaustive here, and set up to initial state ideally
+ // Reset state
+ {
+ request->targetInfos.Clear();
+ // Remove any requests
+ linkage->targets.clear();
+ }
+
LoadContext context(linkage->getSourceManager(), fileSystem);
// Try to set state through API - as doing so means if state stored in multiple places it will be ok
@@ -671,20 +719,41 @@ static void _loadDefines(const Relative32Array<StateSerializeUtil::StringPair>&
linkage->setMatrixLayoutMode(requestState->defaultMatrixLayoutMode);
}
+
+ // Add the target requests
{
for (Index i = 0; i < requestState->targetRequests.getCount(); ++i)
{
TargetRequestState& src = requestState->targetRequests[i];
int index = spAddCodeGenTarget(externalRequest, SlangCompileTarget(src.target));
- SLANG_UNUSED(index);
SLANG_ASSERT(index == i);
- auto dstTarget = linkage->targets[i];
+ auto dstTarget = linkage->targets[index];
SLANG_ASSERT(dstTarget->getTarget() == src.target);
dstTarget->targetProfile = src.profile;
dstTarget->targetFlags = src.targetFlags;
dstTarget->floatingPointMode = src.floatingPointMode;
+
+ // If there is output state (like output filenames) add here
+ if (src.outputStates.getCount())
+ {
+ RefPtr<EndToEndCompileRequest::TargetInfo> dstTargetInfo(new EndToEndCompileRequest::TargetInfo);
+ request->targetInfos[dstTarget] = dstTargetInfo;
+
+ for (const auto& srcOutputState : src.outputStates)
+ {
+ SLANG_ASSERT(srcOutputState.entryPointIndex < requestState->entryPoints.getCount());
+
+ String entryPointPath;
+ if (srcOutputState.outputPath)
+ {
+ entryPointPath = srcOutputState.outputPath->getSlice();
+ }
+
+ dstTargetInfo->entryPointOutputPaths.Add(srcOutputState.entryPointIndex, entryPointPath);
+ }
+ }
}
}
@@ -744,6 +813,9 @@ static void _loadDefines(const Relative32Array<StateSerializeUtil::StringPair>&
// Entry points
{
+ // Check there aren't any set entry point
+ SLANG_ASSERT(request->getFrontEndReq()->m_entryPointReqs.getCount() == 0);
+
for (const auto& srcEntryPoint : requestState->entryPoints)
{
const char* name = srcEntryPoint.name ? srcEntryPoint.name->getCstr() : nullptr;
@@ -782,8 +854,8 @@ static void _loadDefines(const Relative32Array<StateSerializeUtil::StringPair>&
// This is a bit of a hack, we are going to replace the file system, with our one which is filled in
// with what was read from the file.
- linkage->fileSystemExt = cacheFileSystem;
- linkage->cacheFileSystem = cacheFileSystem;
+ linkage->m_fileSystemExt = cacheFileSystem;
+ linkage->m_cacheFileSystem = cacheFileSystem;
}
return SLANG_OK;
@@ -834,11 +906,7 @@ static void _loadDefines(const Relative32Array<StateSerializeUtil::StringPair>&
/* static */SlangResult StateSerializeUtil::loadState(const uint8_t* data, size_t size, List<uint8_t>& outBuffer)
{
- MemoryStream stream(FileAccess::Read);
-
- stream.m_contents.setCount(size);
- ::memcpy(stream.m_contents.getBuffer(), data, size);
-
+ MemoryStreamBase stream(FileAccess::Read, data, size);
return loadState(&stream, outBuffer);
}
diff --git a/source/slang/slang-state-serialize.h b/source/slang/slang-state-serialize.h
index f43cc8d45..dbd1e3992 100644
--- a/source/slang/slang-state-serialize.h
+++ b/source/slang/slang-state-serialize.h
@@ -52,6 +52,12 @@ struct StateSerializeUtil
Relative32Ptr<PathInfoState> pathInfo;
};
+ struct OutputState
+ {
+ int32_t entryPointIndex;
+ Relative32Ptr<RelativeString> outputPath;
+ };
+
// spSetCodeGenTarget/spAddCodeGenTarget
// spSetTargetProfile
// spSetTargetFlags
@@ -63,6 +69,8 @@ struct StateSerializeUtil
CodeGenTarget target;
SlangTargetFlags targetFlags;
FloatingPointMode floatingPointMode;
+
+ Relative32Array<OutputState> outputStates;
};
struct FileReference
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index 19ac6ea1f..8479d3202 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -800,11 +800,11 @@ SlangResult Linkage::loadFile(String const& path, PathInfo& outPathInfo, ISlangB
{
outPathInfo.type = PathInfo::Type::Unknown;
- SLANG_RETURN_ON_FAIL(fileSystemExt->loadFile(path.getBuffer(), outBlob));
+ SLANG_RETURN_ON_FAIL(m_fileSystemExt->loadFile(path.getBuffer(), outBlob));
ComPtr<ISlangBlob> uniqueIdentity;
// Get the unique identity
- SLANG_RETURN_ON_FAIL(fileSystemExt->getFileUniqueIdentity(path.getBuffer(), uniqueIdentity.writeRef()));
+ SLANG_RETURN_ON_FAIL(m_fileSystemExt->getFileUniqueIdentity(path.getBuffer(), uniqueIdentity.writeRef()));
outPathInfo.foundPath = path;
outPathInfo.type = PathInfo::Type::FoundPath;
@@ -2489,17 +2489,17 @@ static const Slang::Guid IID_SlangCacheFileSystem = SLANG_UUID_CacheFileSystem;
void Linkage::setFileSystem(ISlangFileSystem* inFileSystem)
{
// Set the fileSystem
- fileSystem = inFileSystem;
+ m_fileSystem = inFileSystem;
// Release what's there
- fileSystemExt.setNull();
- cacheFileSystem.setNull();
+ m_fileSystemExt.setNull();
+ m_cacheFileSystem.setNull();
// If nullptr passed in set up default
if (inFileSystem == nullptr)
{
- cacheFileSystem = new Slang::CacheFileSystem(Slang::OSFileSystemExt::getSingleton());
- fileSystemExt = cacheFileSystem;
+ m_cacheFileSystem = new Slang::CacheFileSystem(Slang::OSFileSystemExt::getSingleton());
+ m_fileSystemExt = m_cacheFileSystem;
}
else
{
@@ -2507,34 +2507,34 @@ void Linkage::setFileSystem(ISlangFileSystem* inFileSystem)
inFileSystem->queryInterface(IID_SlangCacheFileSystem, (void**)&cacheFileSystemPtr);
if (cacheFileSystemPtr)
{
- cacheFileSystem = cacheFileSystemPtr;
- fileSystemExt = cacheFileSystemPtr;
+ m_cacheFileSystem = cacheFileSystemPtr;
+ m_fileSystemExt = cacheFileSystemPtr;
}
else
{
if (m_requireCacheFileSystem)
{
- cacheFileSystem = new Slang::CacheFileSystem(inFileSystem);
- fileSystemExt = cacheFileSystem;
+ m_cacheFileSystem = new Slang::CacheFileSystem(inFileSystem);
+ m_fileSystemExt = m_cacheFileSystem;
}
else
{
// See if we have the full ISlangFileSystemExt interface, if we do just use it
- inFileSystem->queryInterface(IID_ISlangFileSystemExt, (void**)fileSystemExt.writeRef());
+ inFileSystem->queryInterface(IID_ISlangFileSystemExt, (void**)m_fileSystemExt.writeRef());
// If not wrap with CacheFileSystem that emulates ISlangFileSystemExt from the ISlangFileSystem interface
- if (!fileSystemExt)
+ if (!m_fileSystemExt)
{
// Construct a wrapper to emulate the extended interface behavior
- cacheFileSystem = new Slang::CacheFileSystem(fileSystem);
- fileSystemExt = cacheFileSystem;
+ m_cacheFileSystem = new Slang::CacheFileSystem(m_fileSystem);
+ m_fileSystemExt = m_cacheFileSystem;
}
}
}
}
// Set the file system used on the source manager
- getSourceManager()->setFileSystemExt(fileSystemExt);
+ getSourceManager()->setFileSystemExt(m_fileSystemExt);
}
void Linkage::setRequireCacheFileSystem(bool requireCacheFileSystem)
@@ -2544,7 +2544,7 @@ void Linkage::setRequireCacheFileSystem(bool requireCacheFileSystem)
return;
}
- ComPtr<ISlangFileSystem> scopeFileSystem(fileSystem);
+ ComPtr<ISlangFileSystem> scopeFileSystem(m_fileSystem);
m_requireCacheFileSystem = requireCacheFileSystem;
setFileSystem(scopeFileSystem);
@@ -3478,17 +3478,44 @@ SLANG_API SlangResult spSaveRepro(
using namespace Slang;
auto request = asInternal(inRequest);
- MemoryStream stream(FileAccess::Write);
+ OwnedMemoryStream stream(FileAccess::Write);
SLANG_RETURN_ON_FAIL(StateSerializeUtil::saveState(request, &stream));
RefPtr<ListBlob> listBlob(new ListBlob);
- listBlob->m_data.swapWith(stream.m_contents);
+
+ // Put the content of the stream in the blob
+ stream.swapContents(listBlob->m_data);
*outBlob = listBlob.detach();
return SLANG_OK;
}
+SLANG_API SlangResult spEnableReproCapture(
+ SlangCompileRequest* inRequest)
+{
+ using namespace Slang;
+ auto request = asInternal(inRequest);
+
+ request->getLinkage()->setRequireCacheFileSystem(true);
+ return SLANG_OK;
+}
+
+SLANG_API SlangResult spExtractRepro(SlangSession* session, const void* reproData, size_t reproDataSize, ISlangFileSystemExt* fileSystem)
+{
+ using namespace Slang;
+ SLANG_UNUSED(session);
+
+ List<uint8_t> buffer;
+ {
+ MemoryStreamBase memoryStream(FileAccess::Read, reproData, reproDataSize);
+ SLANG_RETURN_ON_FAIL(StateSerializeUtil::loadState(&memoryStream, buffer));
+ }
+
+ StateSerializeUtil::RequestState* requestState = StateSerializeUtil::getRequest(buffer);
+ return StateSerializeUtil::extractFiles(requestState, fileSystem);
+}
+
// Reflection API
SLANG_API SlangResult spCompileRequest_getProgram(
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-04 05:57:45 +0000