Feature/serial string pool refactor (#702)

* Ongoing serialization for full debug work.

* Use StringRepresentationCache and StringSlicePool for serialization.

* Removed some older path handling for serialization which had some wrong underlying assumptions.

* Builds with refactored use of SubStringPool in ir-serialize.

* Removed prohibitedCategories because not used anywhere.

* Add category 'compatibility-issue'

* Remove work in progress on debug serialization.

1 files changed, 241 insertions, 199 deletions

diff --git a/source/slang/ir-serialize.cpp b/source/slang/ir-serialize.cpp
index e204944a7..e2fd6d3f8 100644
--- a/source/slang/ir-serialize.cpp
+++ b/source/slang/ir-serialize.cpp
@@ -81,13 +81,183 @@ struct CharReader
 
 } // anonymous
 
-static UnownedStringSlice asStringSlice(const PrefixString* prefixString)
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! StringRepresentationCache !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+StringRepresentationCache::StringRepresentationCache():
+    m_stringTable(nullptr),
+    m_namePool(nullptr),
+    m_scopeManager(nullptr)
+{
+}
+
+void StringRepresentationCache::init(const List<char>* stringTable, NamePool* namePool, ObjectScopeManager* scopeManager)
+{
+    m_stringTable = stringTable;
+    m_namePool = namePool;
+    m_scopeManager = scopeManager;
+
+    // Decode the table
+    m_entries.SetSize(StringSlicePool::kNumDefaultHandles);
+    SLANG_COMPILE_TIME_ASSERT(StringSlicePool::kNumDefaultHandles == 2);
+
+    {
+        Entry& entry = m_entries[0];
+        entry.m_numChars = 0;
+        entry.m_startIndex = 0;
+        entry.m_object = nullptr;
+    }
+    {
+        Entry& entry = m_entries[1];
+        entry.m_numChars = 0;
+        entry.m_startIndex = 0;
+        entry.m_object = nullptr;
+    }
+
+    {
+        const char* start = stringTable->begin();
+        const char* cur = start;
+        const char* end = stringTable->end();
+
+        while (cur < end)
+        {
+            CharReader reader(cur);
+            const int len = GetUnicodePointFromUTF8(reader);
+
+            Entry entry;
+            entry.m_startIndex = uint32_t(reader.m_pos - start);
+            entry.m_numChars = len;
+            entry.m_object = nullptr;
+
+            m_entries.Add(entry);
+
+            cur = reader.m_pos + len;
+        }
+    }
+
+    m_entries.Compress();
+}
+
+Name* StringRepresentationCache::getName(Handle handle)
+{
+    if (handle == StringSlicePool::kNullHandle)
+    {
+        return nullptr;
+    }
+
+    Entry& entry = m_entries[int(handle)];
+    if (entry.m_object)
+    {
+        Name* name = dynamic_cast<Name*>(entry.m_object);
+        if (name)
+        {
+            return name;
+        }
+        StringRepresentation* stringRep = static_cast<StringRepresentation*>(entry.m_object);
+        // Promote it to a name
+        name = m_namePool->getName(String(stringRep));
+        entry.m_object = name;
+        return name;
+    }
+
+    Name* name = m_namePool->getName(String(getStringSlice(handle)));
+    entry.m_object = name;
+    return name;
+}
+
+String StringRepresentationCache::getString(Handle handle)
+{
+    return String(getStringRepresentation(handle));
+}
+
+UnownedStringSlice StringRepresentationCache::getStringSlice(Handle handle) const
+{
+    const Entry& entry = m_entries[int(handle)];
+    const char* start = m_stringTable->begin();
+
+    return UnownedStringSlice(start + entry.m_startIndex, int(entry.m_numChars));
+}
+
+StringRepresentation* StringRepresentationCache::getStringRepresentation(Handle handle)
+{
+    if (handle == StringSlicePool::kNullHandle || handle == StringSlicePool::kEmptyHandle)
+    {
+        return nullptr;
+    }
+
+    Entry& entry = m_entries[int(handle)];
+    if (entry.m_object)
+    {
+        Name* name = dynamic_cast<Name*>(entry.m_object);
+        if (name)
+        {
+            return name->text.getStringRepresentation();
+        }
+        return static_cast<StringRepresentation*>(entry.m_object);
+    }
+
+    const UnownedStringSlice slice = getStringSlice(handle);
+    const UInt size = slice.size();
+
+    StringRepresentation* stringRep = StringRepresentation::createWithCapacityAndLength(size, size);
+    memcpy(stringRep->getData(), slice.begin(), size);
+    entry.m_object = stringRep;
+
+    // Keep the StringRepresentation in scope
+    m_scopeManager->add(stringRep);
+    
+    return stringRep;
+}
+
+char* StringRepresentationCache::getCStr(Handle handle)
+{
+    // It turns out StringRepresentation is always 0 terminated, so can just use that
+    StringRepresentation* rep = getStringRepresentation(handle);
+    return rep->getData();
+}
+
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SerialStringTableUtil !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+/* static */void SerialStringTableUtil::encodeStringTable(const StringSlicePool& pool, List<char>& stringTable)
+{
+    // Skip the default handles -> nothing is encoded via them
+    return encodeStringTable(pool.getSlices().begin() + StringSlicePool::kNumDefaultHandles, pool.getNumSlices() - StringSlicePool::kNumDefaultHandles, stringTable);
+}
+    
+/* static */void SerialStringTableUtil::encodeStringTable(const UnownedStringSlice* slices, size_t numSlices, List<char>& stringTable)
+{
+    stringTable.Clear();
+    for (size_t i = 0; i < numSlices; ++i)
+    {
+        const UnownedStringSlice slice = slices[i];
+        const int len = int(slice.size());
+        
+        // We need to write into the the string array
+        char prefixBytes[6];
+        const int numPrefixBytes = EncodeUnicodePointToUTF8(prefixBytes, len);
+        const int baseIndex = int(stringTable.Count());
+
+        stringTable.SetSize(baseIndex + numPrefixBytes + len);
+
+        char* dst = stringTable.begin() + baseIndex;
+
+        memcpy(dst, prefixBytes, numPrefixBytes);
+        memcpy(dst + numPrefixBytes, slice.begin(), len);   
+    }
+}
+
+/* static */void SerialStringTableUtil::decodeStringTable(const List<char>& stringTable, List<UnownedStringSlice>& slices)
 {
-    const char* prefix = (char*)prefixString;
+    const char* start = stringTable.begin();
+    const char* cur = start;
+    const char* end = stringTable.end();
 
-    CharReader reader(prefix);
-    const int len = GetUnicodePointFromUTF8(reader);
-    return UnownedStringSlice(reader.m_pos, len);
+    while (cur < end)
+    {
+        CharReader reader(cur);
+        const int len = GetUnicodePointFromUTF8(reader);
+        slices.Add(UnownedStringSlice(reader.m_pos, len));
+        cur = reader.m_pos + len;
+    }
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! IRSerialData !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -105,8 +275,15 @@ size_t IRSerialData::calcSizeInBytes() const
         _calcArraySize(m_childRuns) + 
         _calcArraySize(m_decorationRuns) + 
         _calcArraySize(m_externalOperands) + 
-        _calcArraySize(m_rawSourceLocs) + 
-        _calcArraySize(m_strings);
+        _calcArraySize(m_stringTable) + 
+        /* Raw source locs */
+        _calcArraySize(m_rawSourceLocs) +
+        /* Debug */
+        _calcArraySize(m_debugSourceFiles) + 
+        _calcArraySize(m_debugLineOffsets) + 
+        _calcArraySize(m_debugViewEntries) + 
+        _calcArraySize(m_debugLocRuns) + 
+        _calcArraySize(m_debugStrings);
 }
 
 void IRSerialData::clear()
@@ -120,9 +297,16 @@ void IRSerialData::clear()
     m_externalOperands.Clear();
     m_rawSourceLocs.Clear();
 
-    m_strings.SetSize(2);
-    m_strings[int(kNullStringIndex)] = 0;
-    m_strings[int(kEmptyStringIndex)] = 0;
+    // Debug data
+    m_debugSourceFiles.Clear(); 
+    m_debugLineOffsets.Clear(); 
+    m_debugViewEntries.Clear(); 
+    m_debugLocRuns.Clear();     
+    m_debugStrings.Clear();
+
+    m_stringTable.SetSize(2);
+    m_stringTable[int(kNullStringIndex)] = 0;
+    m_stringTable[int(kEmptyStringIndex)] = 0;
 
     m_decorationBaseIndex = 0;
 }
@@ -166,7 +350,7 @@ bool IRSerialData::operator==(const ThisType& rhs) const
         _isEqual(m_decorationRuns, rhs.m_decorationRuns) &&
         _isEqual(m_externalOperands, rhs.m_externalOperands) &&
         _isEqual(m_rawSourceLocs, rhs.m_rawSourceLocs) &&
-        _isEqual(m_strings, rhs.m_strings));
+        _isEqual(m_stringTable, rhs.m_stringTable));
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! IRSerialWriter !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -208,17 +392,28 @@ void IRSerialWriter::_addInstruction(IRInst* inst)
     }
 }
 
-IRSerialData::StringIndex IRSerialWriter::getStringIndex(Name* name) 
-{ 
-    return name ? getStringIndex(name->text.getStringRepresentation()) : Ser::kNullStringIndex; 
-}
-
-UnownedStringSlice IRSerialWriter::getStringSlice(Ser::StringIndex index) const
+// Find a view index that matches the view by file (and perhaps other characteristics in the future)
+int _findSourceViewIndex(const List<SourceView*>& viewsIn, SourceView* view)
 {
-    Ser::StringOffset offset = m_stringStarts[int(index)];
-    return asStringSlice((const PrefixString*)(m_serialData->m_strings.begin() + int(offset)));
+    const int numViews = int(viewsIn.Count());
+    SourceView*const* views = viewsIn.begin();
+    
+    SourceFile* sourceFile = view->getSourceFile();
+
+    for (int i = 0; i < numViews; ++i)
+    {
+        SourceView* curView = views[i];
+        // For now we just match on source file
+        if (curView->getSourceFile() == sourceFile)
+        {
+            // It's a hit
+            return i;
+        }
+    }
+    return -1;
 }
 
+
 Result IRSerialWriter::write(IRModule* module, SourceManager* sourceManager, OptionFlags options, IRSerialData* serialData)
 {
     typedef Ser::Inst::PayloadType PayloadType;
@@ -229,23 +424,6 @@ Result IRSerialWriter::write(IRModule* module, SourceManager* sourceManager, Opt
 
     serialData->clear();
 
-    // Set up the stringStarts
-    m_stringStarts.SetSize(2);
-    m_stringStarts[0] = Ser::StringOffset(0);                  // Null
-    m_stringStarts[1] = Ser::StringOffset(1);                  // Empty
-    SLANG_ASSERT(serialData->m_strings.Count() == 2);
-
-    // We'll keep StringRepresentations in scope (and for simplicity keep in order of StringIndex)
-    m_scopeStrings.SetSize(2);
-    m_scopeStrings[0] = nullptr;
-    m_scopeStrings[1] = nullptr;
-
-    m_stringMap.Clear();
-
-    // Add the empty string index. 
-    // We can't add the null string index, because that doesn't have any meaning as an UnownedStringSlice
-    m_stringMap.Add(UnownedStringSlice(""), Ser::kEmptyStringIndex);
-
     // We reserve 0 for null
     m_insts.Clear();
     m_insts.Add(nullptr);
@@ -556,6 +734,12 @@ Result IRSerialWriter::write(IRModule* module, SourceManager* sourceManager, Opt
         }
     }
 
+    // Convert strings into a string table
+    {
+        SerialStringTableUtil::encodeStringTable(m_stringSlicePool, serialData->m_stringTable);
+    }
+
+
     // If the option to use RawSourceLocations is enabled, serialize out as is
     if (options & OptionFlag::RawSourceLocation)
     {
@@ -571,80 +755,11 @@ Result IRSerialWriter::write(IRModule* module, SourceManager* sourceManager, Opt
             dstLocs[i] = Ser::RawSourceLoc(srcInst->sourceLoc.getRaw());
         }
     }
-
+    
     m_serialData = nullptr;
     return SLANG_OK;
 }
 
-IRSerialData::StringIndex IRSerialWriter::getStringIndex(StringRepresentation* rep)
-{
-    if (rep == nullptr)
-    {
-        return Ser::kNullStringIndex;
-    }
-
-    const UnownedStringSlice slice(rep->getData(), rep->getLength());
-    const int len = int(rep->getLength());
-
-    Ser::StringIndex index;
-    if (m_stringMap.TryGetValue(slice, index))
-    {
-        return index;
-    }
-
-    // We need to write into the the string array
-    char prefixBytes[6];
-    const int numPrefixBytes = EncodeUnicodePointToUTF8(prefixBytes, len);
-    const int baseIndex = int(m_serialData->m_strings.Count());
-
-    m_serialData->m_strings.SetSize(baseIndex + numPrefixBytes + len);
-
-    char* dst = m_serialData->m_strings.begin() + baseIndex;
-
-    memcpy(dst, prefixBytes, numPrefixBytes);
-    memcpy(dst + numPrefixBytes, slice.begin(), len);
-
-    // We need to add 1, because the 0 is used for null, which is not in the map
-    const Ser::StringIndex stringIndex = Ser::StringIndex(m_stringMap.Count() + 1);
-
-    SLANG_ASSERT(stringIndex == Ser::StringIndex(m_scopeStrings.Count()));
-    // Make sure the rep stays in scope (because the UnownedStringSlice is pointing to it's contents)
-    m_scopeStrings.Add(rep);
-
-    // Add the start offset
-    m_stringStarts.Add(Ser::StringOffset(baseIndex));
-    m_stringMap.Add(slice, stringIndex);
-
-    return stringIndex;
-}
-
-IRSerialData::StringIndex IRSerialWriter::getStringIndex(const char* chars)
-{
-    if (!chars)
-    {
-        return Ser::kNullStringIndex;
-    }
-    if (chars[0] == 0)
-    {
-        return Ser::kEmptyStringIndex;
-    }
-
-    // Get as a StringRepresentation
-    String string(chars);
-    return getStringIndex(string.getStringRepresentation());
-}
-
-IRSerialData::StringIndex IRSerialWriter::getStringIndex(const UnownedStringSlice& slice)
-{
-    const int len = int(slice.size());
-    if (len <= 0)
-    {
-        return Ser::kEmptyStringIndex;
-    }
-    String string(slice);
-    return getStringIndex(string.getStringRepresentation());
-}
-
 template <typename T>
 static size_t _calcChunkSize(IRSerialBinary::CompressionType compressionType, const List<T>& array)
 {
@@ -966,7 +1081,7 @@ static size_t _calcInstChunkSize(IRSerialBinary::CompressionType compressionType
         _calcChunkSize(compressionType, data.m_childRuns) +
         _calcChunkSize(compressionType, data.m_decorationRuns) +
         _calcChunkSize(compressionType, data.m_externalOperands) +
-        _calcChunkSize(Bin::CompressionType::None, data.m_strings) + 
+        _calcChunkSize(Bin::CompressionType::None, data.m_stringTable) + 
         _calcChunkSize(Bin::CompressionType::None, data.m_rawSourceLocs);
 
     {
@@ -990,7 +1105,7 @@ static size_t _calcInstChunkSize(IRSerialBinary::CompressionType compressionType
     SLANG_RETURN_ON_FAIL(_writeArrayChunk(compressionType, Bin::kChildRunFourCc, data.m_childRuns, stream));
     SLANG_RETURN_ON_FAIL(_writeArrayChunk(compressionType, Bin::kDecoratorRunFourCc, data.m_decorationRuns, stream));
     SLANG_RETURN_ON_FAIL(_writeArrayChunk(compressionType, Bin::kExternalOperandsFourCc, data.m_externalOperands, stream));
-    SLANG_RETURN_ON_FAIL(_writeArrayChunk(Bin::CompressionType::None, Bin::kStringFourCc, data.m_strings, stream));
+    SLANG_RETURN_ON_FAIL(_writeArrayChunk(Bin::CompressionType::None, Bin::kStringFourCc, data.m_stringTable, stream));
 
     SLANG_RETURN_ON_FAIL(_writeArrayChunk(Bin::CompressionType::None, Bin::kUInt32SourceLocFourCc, data.m_rawSourceLocs, stream));
     
@@ -1345,7 +1460,7 @@ int64_t _calcChunkTotalSize(const IRSerialBinary::Chunk& chunk)
             }
             case Bin::kStringFourCc:
             {
-                SLANG_RETURN_ON_FAIL(_readArrayUncompressedChunk(slangHeader, chunk, stream, &bytesRead, dataOut->m_strings));
+                SLANG_RETURN_ON_FAIL(_readArrayUncompressedChunk(slangHeader, chunk, stream, &bytesRead, dataOut->m_stringTable));
                 remainingBytes -= _calcChunkTotalSize(chunk);
                 break;
             }
@@ -1367,85 +1482,6 @@ int64_t _calcChunkTotalSize(const IRSerialBinary::Chunk& chunk)
     return SLANG_OK;
 }
 
-Name* IRSerialReader::getName(Ser::StringIndex index)
-{
-    if (index == Ser::kNullStringIndex)
-    {
-        return nullptr;
-    }
-
-    StringRepresentation* rep = getStringRepresentation(index);
-    String string(rep);
-    Session* session = m_module->getSession();
-
-    return session->getNameObj(string);
-}
-
-String IRSerialReader::getString(Ser::StringIndex index)
-{
-    return String(getStringRepresentation(index));
-}
-
-UnownedStringSlice IRSerialReader::getStringSlice(Ser::StringOffset offset)
-{
-    return asStringSlice((PrefixString*)(m_serialData->m_strings.begin() + int(offset)));
-}
-
-StringRepresentation* IRSerialReader::getStringRepresentation(Ser::StringIndex index)
-{
-    if (index == Ser::kNullStringIndex)
-    {
-        return nullptr;
-    }
-
-    StringRepresentation* rep = m_stringRepresentationCache[int(index)];
-    if (rep)
-    {
-        return rep;
-    }
-
-    const UnownedStringSlice slice = getStringSlice(index);
-    String string(slice);
-
-    StringRepresentation* stringRep = string.getStringRepresentation();   
-    m_module->addRefObjectToFree(stringRep);
-
-    m_stringRepresentationCache[int(index)] = stringRep;
-
-    return stringRep;
-}
-
-char* IRSerialReader::getCStr(Ser::StringIndex index)
-{
-    // It turns out StringRepresentation is always 0 terminated, so can just use that
-    StringRepresentation* rep = getStringRepresentation(index);
-    return rep->getData();
-}
-
-void IRSerialReader::_calcStringStarts()
-{
-    m_stringStarts.Clear();
-
-    const char* start = m_serialData->m_strings.begin();
-    const char* cur = start;
-    const char* end = m_serialData->m_strings.end();
-
-    while (cur < end)
-    {
-        m_stringStarts.Add(Ser::StringOffset(cur - start));
-
-        CharReader reader(cur);
-        const int len = GetUnicodePointFromUTF8(reader);
-        cur = reader.m_pos + len;
-    }
-
-    m_stringRepresentationCache.Clear();
-    // Resize cache
-    m_stringRepresentationCache.SetSize(m_stringStarts.Count());
-    // Make sure all values are null initially
-    memset(m_stringRepresentationCache.begin(), 0, sizeof(StringRepresentation*) * m_stringStarts.Count());
-}
-
 IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
 {
     typedef Ser::Inst::PayloadType PayloadType;
@@ -1478,29 +1514,29 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
         {
             auto decor = createEmptyDecoration<IRTargetDecoration>(m_module);
             SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
-            decor->targetName = getStringRepresentation(srcInst.m_payload.m_stringIndices[0]);
+            decor->targetName = m_stringRepresentationCache.getStringRepresentation(StringHandle(srcInst.m_payload.m_stringIndices[0]));
             return decor;
         }
         case kIRDecorationOp_TargetIntrinsic:
         {
             auto decor = createEmptyDecoration<IRTargetIntrinsicDecoration>(m_module);
             SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_2);
-            decor->targetName = getStringRepresentation(srcInst.m_payload.m_stringIndices[0]);
-            decor->definition = getStringRepresentation(srcInst.m_payload.m_stringIndices[1]);
+            decor->targetName = m_stringRepresentationCache.getStringRepresentation(StringHandle(srcInst.m_payload.m_stringIndices[0]));
+            decor->definition = m_stringRepresentationCache.getStringRepresentation(StringHandle(srcInst.m_payload.m_stringIndices[1]));
             return decor;
         }
         case kIRDecorationOp_GLSLOuterArray:
         {
             auto decor = createEmptyDecoration<IRGLSLOuterArrayDecoration>(m_module);
             SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
-            decor->outerArrayName = getCStr(srcInst.m_payload.m_stringIndices[0]);
+            decor->outerArrayName = m_stringRepresentationCache.getCStr(StringHandle(srcInst.m_payload.m_stringIndices[0]));
             return decor;
         }
         case kIRDecorationOp_Semantic:
         {
             auto decor = createEmptyDecoration<IRSemanticDecoration>(m_module);
             SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
-            decor->semanticName = getName(srcInst.m_payload.m_stringIndices[0]);
+            decor->semanticName = m_stringRepresentationCache.getName(StringHandle(srcInst.m_payload.m_stringIndices[0]));
             return decor;
         }
         case kIRDecorationOp_InterpolationMode:
@@ -1514,7 +1550,7 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
         {
             auto decor = createEmptyDecoration<IRNameHintDecoration>(m_module);
             SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
-            decor->name = getName(srcInst.m_payload.m_stringIndices[0]);
+            decor->name = m_stringRepresentationCache.getName(StringHandle(srcInst.m_payload.m_stringIndices[0]));
             return decor;
         }
         case kIRDecorationOp_VulkanRayPayload:
@@ -1533,7 +1569,7 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
         {
             auto decor = createEmptyDecoration<IRRequireGLSLExtensionDecoration>(m_module);
             SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
-            decor->extensionName = getStringRepresentation(srcInst.m_payload.m_stringIndices[0]);
+            decor->extensionName = m_stringRepresentationCache.getStringRepresentation(StringHandle(srcInst.m_payload.m_stringIndices[0]));
             return decor;
         }
         case kIRDecorationOp_RequireGLSLVersion:
@@ -1556,13 +1592,15 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
     typedef Ser::Inst::PayloadType PayloadType;
 
     m_serialData = &data;
-    _calcStringStarts();
-
+ 
     auto module = new IRModule();
     moduleOut = module;
     m_module = module;
 
     module->session = session;
+
+    // Set up the string rep cache
+    m_stringRepresentationCache.init(&data.m_stringTable, session->getNamePool(), module->getObjectScopeManager());
     
     // Add all the instructions
 
@@ -1613,7 +1651,7 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
                 insts[i] = globalValueInst;
                 // Set the global value
                 SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
-                globalValueInst->mangledName = getName(srcInst.m_payload.m_stringIndices[0]);
+                globalValueInst->mangledName = m_stringRepresentationCache.getName(StringHandle(srcInst.m_payload.m_stringIndices[0]));
             }
             else
             {
@@ -1659,7 +1697,7 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
                     {
                         SLANG_ASSERT(srcInst.m_payloadType == PayloadType::String_1);
 
-                        const UnownedStringSlice slice = getStringSlice(srcInst.m_payload.m_stringIndices[0]);
+                        const UnownedStringSlice slice = m_stringRepresentationCache.getStringSlice(StringHandle(srcInst.m_payload.m_stringIndices[0]));
                         
                         const size_t sliceSize = slice.size();
                         const size_t instSize = prefixSize + SLANG_OFFSET_OF(IRConstant::StringValue, chars) + sliceSize;
@@ -1813,6 +1851,8 @@ IRDecoration* IRSerialReader::_createDecoration(const Ser::Inst& srcInst)
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!! Free functions !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
+#if 0
+
 Result serializeModule(IRModule* module, SourceManager* sourceManager, Stream* stream)
 {
     IRSerialWriter serializer;
@@ -1837,4 +1877,6 @@ Result readModule(Session* session, Stream* stream, RefPtr<IRModule>& moduleOut)
     return reader.read(serialData, session, moduleOut);
 }
 
+#endif
+
 } // namespace Slang