summaryrefslogtreecommitdiffstats
path: root/source/slang
diff options
context:
space:
mode:
Diffstat (limited to 'source/slang')
-rw-r--r--source/slang/slang-ast-builder.h15
-rw-r--r--source/slang/slang-check-expr.cpp4
-rw-r--r--source/slang/slang-compiler.cpp24
-rwxr-xr-xsource/slang/slang-compiler.h119
-rw-r--r--source/slang/slang-hash-utils.h55
-rw-r--r--source/slang/slang-serialize-ast.cpp25
-rw-r--r--source/slang/slang-serialize-ast.h2
-rw-r--r--source/slang/slang-serialize-type-info.h12
-rw-r--r--source/slang/slang-serialize.cpp17
-rw-r--r--source/slang/slang-serialize.h25
-rw-r--r--source/slang/slang.cpp175
11 files changed, 460 insertions, 13 deletions
diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h
index 3023e274d..91fe63c88 100644
--- a/source/slang/slang-ast-builder.h
+++ b/source/slang/slang-ast-builder.h
@@ -155,9 +155,20 @@ public:
/// Create AST types
template <typename T>
- T* create() { return _initAndAdd(new (m_arena.allocate(sizeof(T))) T); }
+ T* create()
+ {
+ auto alloced = m_arena.allocate(sizeof(T));
+ memset(alloced, 0, sizeof(T));
+ return _initAndAdd(new (alloced) T);
+ }
+
template<typename T, typename... TArgs>
- T* create(TArgs... args) { return _initAndAdd(new (m_arena.allocate(sizeof(T))) T(args...)); }
+ T* create(TArgs... args)
+ {
+ auto alloced = m_arena.allocate(sizeof(T));
+ memset(alloced, 0, sizeof(T));
+ return _initAndAdd(new (alloced) T(args...));
+ }
template<typename T, typename ... TArgs>
SLANG_FORCE_INLINE T* getOrCreate(TArgs ... args)
diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index 2987fecee..f1ccddf15 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -2195,6 +2195,10 @@ namespace Slang
SwizzleExpr* swizExpr = m_astBuilder->create<SwizzleExpr>();
swizExpr->loc = memberRefExpr->loc;
swizExpr->base = memberRefExpr->baseExpression;
+ swizExpr->elementIndices[0] = 0;
+ swizExpr->elementIndices[1] = 0;
+ swizExpr->elementIndices[2] = 0;
+ swizExpr->elementIndices[3] = 0;
swizExpr->memberOpLoc = memberRefExpr->memberOperatorLoc;
IntegerLiteralValue limitElement = baseElementCount;
diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp
index 06cc9d759..889ecc58a 100644
--- a/source/slang/slang-compiler.cpp
+++ b/source/slang/slang-compiler.cpp
@@ -35,6 +35,7 @@
#include "slang-glsl-extension-tracker.h"
#include "slang-emit-cuda.h"
+#include "slang-serialize-ast.h"
#include "slang-serialize-container.h"
namespace Slang
@@ -222,6 +223,16 @@ namespace Slang
visitor->visitEntryPoint(this, as<EntryPointSpecializationInfo>(specializationInfo));
}
+ void EntryPoint::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt entryPointIndex)
+ {
+ // CompositeComponentType will have already hashed the relevant entry point's name
+ // and file path dependencies, so we immediately return.
+ SLANG_UNUSED(builder);
+ SLANG_UNUSED(entryPointIndex);
+ }
+
List<Module*> const& EntryPoint::getModuleDependencies()
{
if(auto module = getModule())
@@ -290,6 +301,19 @@ namespace Slang
return Super::getInterface(guid);
}
+ void TypeConformance::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt entryPointIndex)
+ {
+ SLANG_UNUSED(entryPointIndex);
+
+ //TODO: Implement some kind of hashInto for Val then replace this
+ auto subtypeWitness = m_subtypeWitness->toString();
+
+ builder.addToDigest(subtypeWitness);
+ builder.addToDigest(m_conformanceIdOverride);
+ }
+
List<Module*> const& TypeConformance::getModuleDependencies()
{
return m_moduleDependency.getModuleList();
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
index 46be07fa3..016c8fefa 100755
--- a/source/slang/slang-compiler.h
+++ b/source/slang/slang-compiler.h
@@ -3,6 +3,7 @@
#include "../core/slang-basic.h"
#include "../core/slang-shared-library.h"
+#include "../core/slang-digest.h"
#include "../compiler-core/slang-downstream-compiler.h"
#include "../compiler-core/slang-downstream-compiler-util.h"
@@ -282,14 +283,23 @@ namespace Slang
const char* newName,
slang::IComponentType** outEntryPoint) SLANG_OVERRIDE;
SLANG_NO_THROW SlangResult SLANG_MCALL link(
- slang::IComponentType** outLinkedComponentType,
- ISlangBlob** outDiagnostics) SLANG_OVERRIDE;
+ slang::IComponentType** outLinkedComponentType,
+ ISlangBlob** outDiagnostics) SLANG_OVERRIDE;
SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable(
int entryPointIndex,
int targetIndex,
ISlangSharedLibrary** outSharedLibrary,
slang::IBlob** outDiagnostics) SLANG_OVERRIDE;
+ /// ComponentType is the only class inheriting from IComponentType that provides a
+ /// meaningful implementation for these two functions. All others should forward these
+ /// and implement updateDependencyBasedHash and updateASTBasedHash instead.
+ SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash(
+ SlangInt entryPointIndex,
+ SlangInt targetIndex,
+ slang::Digest* outHash) SLANG_OVERRIDE;
+ SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash) SLANG_OVERRIDE;
+
/// Get the linkage (aka "session" in the public API) for this component type.
Linkage* getLinkage() { return m_linkage; }
@@ -298,6 +308,16 @@ namespace Slang
/// The `target` must be a target on the `Linkage` that was used to create this program.
TargetProgram* getTargetProgram(TargetRequest* target);
+ /// Update the hash builder with the dependencies for this component type.
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) = 0;
+
+ /// Update the hash builder with the AST contents for this component type.
+ /// The AST is associated with a Module component, so most derived ComponentType classes
+ /// will simply do nothing with this.
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) = 0;
+
/// Get the number of entry points linked into this component type.
virtual Index getEntryPointCount() = 0;
@@ -495,6 +515,12 @@ namespace Slang
Linkage* linkage,
List<RefPtr<ComponentType>> const& childComponents);
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) override;
+
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override;
+
List<RefPtr<ComponentType>> const& getChildComponents() { return m_childComponents; };
Index getChildComponentCount() { return m_childComponents.getCount(); }
RefPtr<ComponentType> getChildComponent(Index index) { return m_childComponents[index]; }
@@ -571,6 +597,15 @@ namespace Slang
List<SpecializationArg> const& specializationArgs,
DiagnosticSink* sink);
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) override;
+
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override
+ {
+ SLANG_UNUSED(hashBuilder);
+ }
+
/// Get the base (unspecialized) component type that is being specialized.
RefPtr<ComponentType> getBaseComponentType() { return m_base; }
@@ -754,6 +789,16 @@ namespace Slang
void acceptVisitor(ComponentTypeVisitor* visitor, SpecializationInfo* specializationInfo)
SLANG_OVERRIDE;
+
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) override;
+
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override
+ {
+ SLANG_UNUSED(hashBuilder);
+ }
+
private:
RefPtr<ComponentType> m_base;
String m_entryPointNameOverride;
@@ -846,6 +891,28 @@ namespace Slang
return Super::getEntryPointHostCallable(entryPointIndex, targetIndex, outSharedLibrary, outDiagnostics);
}
+ SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash(
+ SlangInt entryPointIndex,
+ SlangInt targetIndex,
+ slang::Digest* outHash) SLANG_OVERRIDE
+ {
+ return Super::computeDependencyBasedHash(entryPointIndex, targetIndex, outHash);
+ }
+
+ SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash)
+ {
+ return Super::computeASTBasedHash(outHash);
+ }
+
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) override;
+
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override
+ {
+ SLANG_UNUSED(hashBuilder);
+ }
+
/// Create an entry point that refers to the given function.
static RefPtr<EntryPoint> create(
Linkage* linkage,
@@ -1051,6 +1118,28 @@ namespace Slang
entryPointIndex, targetIndex, outSharedLibrary, outDiagnostics);
}
+ SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash(
+ SlangInt entryPointIndex,
+ SlangInt targetIndex,
+ slang::Digest* outHash) SLANG_OVERRIDE
+ {
+ return Super::computeDependencyBasedHash(entryPointIndex, targetIndex, outHash);
+ }
+
+ SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash)
+ {
+ return Super::computeASTBasedHash(outHash);
+ }
+
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) override;
+
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override
+ {
+ SLANG_UNUSED(hashBuilder);
+ }
+
List<Module*> const& getModuleDependencies() SLANG_OVERRIDE;
List<String> const& getFilePathDependencies() SLANG_OVERRIDE;
@@ -1225,6 +1314,25 @@ namespace Slang
//
+ SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash(
+ SlangInt entryPointIndex,
+ SlangInt targetIndex,
+ slang::Digest* outHash) SLANG_OVERRIDE
+ {
+ return Super::computeDependencyBasedHash(entryPointIndex, targetIndex, outHash);
+ }
+
+ SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash)
+ {
+ return Super::computeASTBasedHash(outHash);
+ }
+
+ virtual void updateDependencyBasedHash(
+ DigestBuilder& hashBuilder,
+ SlangInt entryPointIndex) override;
+
+ virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override;
+
/// Create a module (initially empty).
Module(Linkage* linkage, ASTBuilder* astBuilder = nullptr);
@@ -1657,6 +1765,13 @@ namespace Slang
SLANG_NO_THROW SlangResult SLANG_MCALL createCompileRequest(
SlangCompileRequest** outCompileRequest) override;
+ // Updates the supplied has builder with linkage-related information, which includes preprocessor
+ // defines, the compiler version, and other compiler options. This is then merged with the hash
+ // produced for the program to produce a key that can be used with the shader cache.
+ void updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt targetIndex);
+
void addTarget(
slang::TargetDesc const& desc);
SlangResult addSearchPath(
diff --git a/source/slang/slang-hash-utils.h b/source/slang/slang-hash-utils.h
new file mode 100644
index 000000000..d0d610cb8
--- /dev/null
+++ b/source/slang/slang-hash-utils.h
@@ -0,0 +1,55 @@
+// slang-hash-utils.h - Utility functions specifically designed to be used with slang::Digest
+#pragma once
+#include "../../slang.h"
+#include "../core/slang-basic.h"
+#include "../core/slang-md5.h"
+#include "../core/slang-digest.h"
+
+namespace Slang
+{
+ // Compute the hash for an UnownedStringSlice
+ inline slang::Digest computeHashForStringSlice(UnownedStringSlice text)
+ {
+ DigestBuilder builder;
+ builder.addToDigest(text);
+
+ slang::Digest textHash;
+ builder.finalize(&textHash);
+
+ return textHash;
+ }
+
+ // Combines the two provided hashes.
+ inline slang::Digest combineHashes(const slang::Digest& hashA, const slang::Digest& hashB)
+ {
+ DigestBuilder builder;
+ builder.addToDigest(hashA);
+ builder.addToDigest(hashB);
+
+ slang::Digest combined;
+ builder.finalize(&combined);
+ return combined;
+ }
+
+ // Returns the stored hash in checksum as a String.
+ inline StringBuilder hashToString(const slang::Digest& hash)
+ {
+ StringBuilder filename;
+
+ for (Index i = 0; i < 4; ++i)
+ {
+ auto hashSegmentString = String(hash.values[i], 16);
+
+ auto leadingZeroCount = 8 - hashSegmentString.getLength();
+ for (Index j = 0; j < leadingZeroCount; ++j)
+ {
+ filename.append("0");
+ }
+ filename.append(hashSegmentString.getBuffer());
+ }
+
+ return filename;
+ }
+
+ // TODO: fromString implementation?
+}
diff --git a/source/slang/slang-serialize-ast.cpp b/source/slang/slang-serialize-ast.cpp
index 31a3f6ac0..04b5f71b1 100644
--- a/source/slang/slang-serialize-ast.cpp
+++ b/source/slang/slang-serialize-ast.cpp
@@ -154,4 +154,29 @@ struct ASTFieldAccess
return SLANG_OK;
}
+/* static */List<uint8_t> ASTSerialUtil::serializeAST(ModuleDecl* moduleDecl)
+{
+ //TODO: we should store `classes` in GlobalSession to avoid recomputing them every time.
+ RefPtr<SerialClasses> classes;
+ SerialClassesUtil::create(classes);
+
+ List<uint8_t> contents;
+ OwnedMemoryStream stream(FileAccess::ReadWrite);
+
+ // Only serialize out things *in* this module
+ ModuleSerialFilter filterStorage(moduleDecl);
+
+ SerialFilter* filter = moduleDecl ? &filterStorage : nullptr;
+
+ SerialWriter writer(classes, filter);
+
+ // Lets serialize it all
+ writer.addPointer(moduleDecl);
+ // Let's stick it all in a stream
+ writer.write(&stream);
+
+ stream.swapContents(contents);
+ return contents;
+}
+
} // namespace Slang
diff --git a/source/slang/slang-serialize-ast.h b/source/slang/slang-serialize-ast.h
index 3aa790c86..1052c9a0a 100644
--- a/source/slang/slang-serialize-ast.h
+++ b/source/slang/slang-serialize-ast.h
@@ -48,6 +48,8 @@ struct ASTSerialUtil
/// Tries to serialize out, read back in and test the results are the same.
/// Will write dumped out node to files
static SlangResult testSerialize(NodeBase* node, RootNamePool* rootNamePool, SharedASTBuilder* sharedASTBuilder, SourceManager* sourceManager);
+
+ static List<uint8_t> serializeAST(ModuleDecl* moduleDecl);
};
} // namespace Slang
diff --git a/source/slang/slang-serialize-type-info.h b/source/slang/slang-serialize-type-info.h
index c80eb8051..6258a129d 100644
--- a/source/slang/slang-serialize-type-info.h
+++ b/source/slang/slang-serialize-type-info.h
@@ -104,6 +104,12 @@ struct SerialTypeInfo<T[N]>
static void toSerial(SerialWriter* writer, const void* inNative, void* outSerial)
{
SerialElementType* serial = (SerialElementType*)outSerial;
+
+ if (writer->getFlags() & SerialWriter::Flag::ZeroInitialize)
+ {
+ ::memset(outSerial, 0, sizeof(SerialElementType) * N);
+ }
+
const T* native = (const T*)inNative;
for (Index i = 0; i < Index(N); ++i)
{
@@ -278,6 +284,12 @@ struct SerialTypeInfo<Dictionary<KEY, VALUE>>
keys.setCount(count);
values.setCount(count);
+ if (writer->getFlags() & SerialWriter::Flag::ZeroInitialize)
+ {
+ ::memset(keys.getBuffer(), 0, count * sizeof(KeySerialType));
+ ::memset(values.getBuffer(), 0, count * sizeof(ValueSerialType));
+ }
+
Index i = 0;
for (const auto& pair : src)
{
diff --git a/source/slang/slang-serialize.cpp b/source/slang/slang-serialize.cpp
index 71ef303b7..9b63d47c5 100644
--- a/source/slang/slang-serialize.cpp
+++ b/source/slang/slang-serialize.cpp
@@ -210,10 +210,11 @@ SerialClasses::SerialClasses():
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SerialWriter !!!!!!!!!!!!!!!!!!!!!!!!!!!!
-SerialWriter::SerialWriter(SerialClasses* classes, SerialFilter* filter) :
- m_arena(2048),
- m_classes(classes),
- m_filter(filter)
+SerialWriter::SerialWriter(SerialClasses* classes, SerialFilter* filter, Flags flags)
+ : m_arena(2048)
+ , m_classes(classes)
+ , m_filter(filter)
+ , m_flags(flags)
{
// 0 is always the null pointer
m_entries.add(nullptr);
@@ -236,6 +237,7 @@ SerialIndex SerialWriter::writeObject(const SerialClass* serialCls, const void*
nodeEntry->typeKind = serialCls->typeKind;
nodeEntry->subType = serialCls->subType;
+ nodeEntry->_pad0 = 0;
nodeEntry->info = SerialInfo::makeEntryInfo(serialCls->alignment);
@@ -244,6 +246,12 @@ SerialIndex SerialWriter::writeObject(const SerialClass* serialCls, const void*
// Point to start of payload
uint8_t* serialPayload = (uint8_t*)(nodeEntry + 1);
+
+ if (m_flags & Flag::ZeroInitialize)
+ {
+ ::memset(serialPayload, 0, serialCls->size);
+ }
+
while (serialCls)
{
for (Index i = 0; i < serialCls->fieldsCount; ++i)
@@ -483,6 +491,7 @@ SlangResult SerialWriter::write(Stream* stream)
for (Index i = 1; i < entriesCount; ++i)
{
SerialInfo::Entry* next = entries[i + 1];
+
// Before writing we need to store the next alignment
const size_t nextAlignment = SerialInfo::getAlignment(next->info);
diff --git a/source/slang/slang-serialize.h b/source/slang/slang-serialize.h
index fcd2daa1f..e08d26dd5 100644
--- a/source/slang/slang-serialize.h
+++ b/source/slang/slang-serialize.h
@@ -316,6 +316,18 @@ void SerialReader::getArray(SerialIndex index, List<T>& out)
class SerialWriter : public RefObject
{
public:
+ typedef uint32_t Flags;
+ struct Flag
+ {
+ enum Enum : Flags
+ {
+ /// If set will zero initialize backing memory. This is slower but
+ /// is desirable to make two serializations of the same thing produce the
+ /// identical serialized result.
+ ZeroInitialize = 0x1
+ };
+ };
+
SerialIndex addPointer(const NodeBase* ptr);
SerialIndex addPointer(const RefObject* ptr);
@@ -367,8 +379,11 @@ public:
/// Used for attaching extra objects necessary for serializing
SerialExtraObjects& getExtraObjects() { return m_extraObjects; }
+ /// Get the flag
+ Flags getFlags() const { return m_flags; }
+
/// Ctor
- SerialWriter(SerialClasses* classes, SerialFilter* filter);
+ SerialWriter(SerialClasses* classes, SerialFilter* filter, Flags flags = Flag::ZeroInitialize);
protected:
@@ -388,7 +403,6 @@ protected:
Dictionary<const void*, Index> m_ptrMap; // Maps a pointer to an entry index
-
// NOTE! Assumes the content stays in scope!
SliceMap m_sliceMap;
SliceMap m_importSymbolMap;
@@ -399,6 +413,8 @@ protected:
MemoryArena m_arena; ///< Holds the payloads
SerialClasses* m_classes;
SerialFilter* m_filter; ///< Filter to control what is serialized
+
+ Flags m_flags; ///< Flags to control behavior
};
// ---------------------------------------------------------------------------
@@ -419,6 +435,11 @@ SerialIndex SerialWriter::addArray(const T* in, Index count)
List<ElementSerialType> work;
work.setCount(count);
+ if (getFlags() & Flag::ZeroInitialize)
+ {
+ ::memset(work.getBuffer(), 0, sizeof(ElementSerialType) * count);
+ }
+
for (Index i = 0; i < count; ++i)
{
ElementTypeInfo::toSerial(this, &in[i], &work[i]);
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index a3fd91ce0..a6dcf8ab2 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -44,6 +44,9 @@
#include "slang-check-impl.h"
+#include "../core/slang-md5.h"
+#include "slang-hash-utils.h"
+
#include "../../slang-tag-version.h"
// Used to print exception type names in internal-compiler-error messages
@@ -1318,6 +1321,54 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createCompileRequest(
return SLANG_OK;
}
+void Linkage::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt targetIndex)
+{
+ // Add the Slang compiler version to the hash
+ auto version = String(getBuildTagString());
+ builder.addToDigest(version);
+
+ // Add the search directory paths to the hash
+ auto searchDirectoryList = getSearchDirectories().searchDirectories;
+ for (auto& searchDir : searchDirectoryList)
+ {
+ auto searchPath = searchDir.path;
+ builder.addToDigest(searchPath);
+ }
+
+ // Add the preprocessor definitions to the hash
+ for (auto& key : preprocessorDefinitions)
+ {
+ builder.addToDigest(key.Key);
+ builder.addToDigest(key.Value);
+ }
+
+ // Add the target specified by targetIndex
+ auto targetReq = targets[targetIndex];
+ builder.addToDigest(targetReq->getTarget());
+ builder.addToDigest(targetReq->getTargetFlags());
+ builder.addToDigest(targetReq->getFloatingPointMode());
+ builder.addToDigest(targetReq->getLineDirectiveMode());
+ builder.addToDigest(targetReq->shouldDumpIntermediates());
+ builder.addToDigest(targetReq->getForceGLSLScalarBufferLayout());
+ builder.addToDigest(targetReq->shouldTrackLiveness());
+
+ auto targetProfile = targetReq->getTargetProfile();
+ builder.addToDigest(targetProfile.getStage());
+ builder.addToDigest(targetProfile.getVersion());
+ builder.addToDigest(targetProfile.getFamily());
+
+ auto targetProfileName = String(targetProfile.getName());
+ builder.addToDigest(targetProfileName);
+
+ auto cookedCapabilities = targetReq->getTargetCaps().getExpandedAtoms();
+ for (auto& capability : cookedCapabilities)
+ {
+ builder.addToDigest(capability);
+ }
+}
+
SlangResult Linkage::addSearchPath(
char const* path)
{
@@ -1618,10 +1669,20 @@ void TranslationUnitRequest::_addSourceFile(SourceFile* sourceFile)
// an associated path and/or wasn't from a file.
auto pathInfo = sourceFile->getPathInfo();
- if (pathInfo.hasFileFoundPath())
+ if (pathInfo.hasFoundPath())
{
getModule()->addFilePathDependency(pathInfo.foundPath);
}
+ else
+ {
+ // No path exists for this source, so we generate a new string to use as a
+ // fake path in the list of file path dependencies. This is needed to account
+ // for non-file-based dependencies later when shader files are being hashed for
+ // the shader cache.
+
+ slang::Digest sourceHash = computeHashForStringSlice(sourceFile->getContent());
+ getModule()->addFilePathDependency(hashToString(sourceHash));
+ }
}
List<SourceFile*> const& TranslationUnitRequest::getSourceFiles()
@@ -3149,8 +3210,6 @@ void FilePathDependencyList::addDependency(Module* module)
}
}
-
-
//
// Module
//
@@ -3178,6 +3237,22 @@ ISlangUnknown* Module::getInterface(const Guid& guid)
return Super::getInterface(guid);
}
+void Module::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt entryPointIndex)
+{
+ // CompositeComponentType will have already hashed this Module's file
+ // dependencies.
+ SLANG_UNUSED(builder);
+ SLANG_UNUSED(entryPointIndex);
+}
+
+void Module::updateASTBasedHash(DigestBuilder& builder)
+{
+ auto serializedAST = ASTSerialUtil::serializeAST(getModuleDecl());
+ builder.addToDigest(serializedAST);
+}
+
void Module::addModuleDependency(Module* module)
{
m_moduleDependencyList.addDependency(module);
@@ -3376,6 +3451,52 @@ SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::getEntryPointCode(
return artifact->loadBlob(ArtifactKeep::Yes, outCode);
}
+SLANG_NO_THROW void SLANG_MCALL ComponentType::computeDependencyBasedHash(
+ SlangInt entryPointIndex,
+ SlangInt targetIndex,
+ slang::Digest* outHash)
+{
+ DigestBuilder builder;
+
+ // A note on enums that may be hashed in as part of the following two function calls:
+ //
+ // While enums are not guaranteed to be encoded the same way across all versions of
+ // the compiler, part of hashing the linkage is hashing in the compiler version.
+ // Consequently, any encoding differences as a result of different compiler versions
+ // will already be reflected in the resulting hash.
+ getLinkage()->updateDependencyBasedHash(builder, targetIndex);
+ updateDependencyBasedHash(builder, entryPointIndex);
+
+ // Add file path dependencies to the hash - all child components
+ // will have file path dependencies that are a subset of this list.
+ auto fileDeps = getFilePathDependencies();
+ for (auto& file : fileDeps)
+ {
+ builder.addToDigest(file);
+ }
+
+ // Add the name and name override for the specified entry point
+ // to the hash.
+ auto entryPointName = getEntryPoint(entryPointIndex)->getName()->text;
+ builder.addToDigest(entryPointName);
+ auto entryPointNameOverride = getEntryPointNameOverride(entryPointIndex);
+ builder.addToDigest(entryPointNameOverride);
+
+ slang::Digest hash;
+ builder.finalize(&hash);
+ *outHash = hash;
+}
+
+SLANG_NO_THROW void SLANG_MCALL ComponentType::computeASTBasedHash(slang::Digest* outHash)
+{
+ DigestBuilder builder;
+ updateASTBasedHash(builder);
+
+ slang::Digest hash;
+ builder.finalize(&hash);
+ *outHash = hash;
+}
+
SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::getEntryPointHostCallable(
int entryPointIndex,
int targetIndex,
@@ -3708,6 +3829,28 @@ CompositeComponentType::CompositeComponentType(
}
}
+void CompositeComponentType::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt entryPointIndex)
+{
+ auto componentCount = getChildComponentCount();
+
+ for (Index i = 0; i < componentCount; ++i)
+ {
+ getChildComponent(i)->updateDependencyBasedHash(builder, entryPointIndex);
+ }
+}
+
+void CompositeComponentType::updateASTBasedHash(DigestBuilder& builder)
+{
+ auto componentCount = getChildComponentCount();
+
+ for (Index i = 0; i < componentCount; ++i)
+ {
+ getChildComponent(i)->updateASTBasedHash(builder);
+ }
+}
+
Index CompositeComponentType::getEntryPointCount()
{
return m_entryPoints.getCount();
@@ -4187,6 +4330,22 @@ SpecializedComponentType::SpecializedComponentType(
collector.visitSpecialized(this);
}
+void SpecializedComponentType::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt entryPointIndex)
+{
+ auto specializationArgCount = getSpecializationArgCount();
+ for (Index i = 0; i < specializationArgCount; ++i)
+ {
+ auto specializationArg = getSpecializationArg(i);
+ auto argString = specializationArg.val->toString();
+ builder.addToDigest(argString);
+ }
+
+ slang::Digest baseHash;
+ getBaseComponentType()->updateDependencyBasedHash(builder, entryPointIndex);
+}
+
void SpecializedComponentType::acceptVisitor(ComponentTypeVisitor* visitor, SpecializationInfo* specializationInfo)
{
SLANG_ASSERT(specializationInfo == nullptr);
@@ -4231,6 +4390,16 @@ void RenamedEntryPointComponentType::acceptVisitor(
this, as<EntryPoint::EntryPointSpecializationInfo>(specializationInfo));
}
+void RenamedEntryPointComponentType::updateDependencyBasedHash(
+ DigestBuilder& builder,
+ SlangInt entryPointIndex)
+{
+ // CompositeComponentType will have already hashed the name override and file
+ // dependencies for this entry point.
+ SLANG_UNUSED(entryPointIndex);
+ SLANG_UNUSED(builder);
+}
+
void ComponentTypeVisitor::visitChildren(CompositeComponentType* composite, CompositeComponentType::CompositeSpecializationInfo* specializationInfo)
{
auto childCount = composite->getChildComponentCount();
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 18:10:17 +0000