1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// slang-module-library.cpp
#include "slang-module-library.h"
#include <assert.h>
#include "../core/slang-blob.h"
#include "../core/slang-riff.h"
#include "../core/slang-type-text-util.h"
// Serialization
#include "slang-serialize-ir.h"
#include "slang-serialize-container.h"
namespace Slang {
void* ModuleLibrary::getInterface(const Guid& uuid)
{
if (uuid == ISlangUnknown::getTypeGuid() ||
uuid == ICastable::getTypeGuid() ||
uuid == IArtifactRepresentation::getTypeGuid() ||
uuid == IModuleLibrary::getTypeGuid())
{
return static_cast<IModuleLibrary*>(this);
}
return nullptr;
}
void* ModuleLibrary::getObject(const Guid& uuid)
{
return uuid == getTypeGuid() ? this : nullptr;
}
void* ModuleLibrary::castAs(const Guid& guid)
{
if (auto intf = getInterface(guid))
{
return intf;
}
return getObject(guid);
}
SlangResult loadModuleLibrary(const Byte* inBytes, size_t bytesCount, EndToEndCompileRequest* req, ComPtr<IModuleLibrary>& outLibrary)
{
auto library = new ModuleLibrary;
ComPtr<IModuleLibrary> scopeLibrary(library);
// Load up the module
MemoryStreamBase memoryStream(FileAccess::Read, inBytes, bytesCount);
RiffContainer riffContainer;
SLANG_RETURN_ON_FAIL(RiffUtil::read(&memoryStream, riffContainer));
auto linkage = req->getLinkage();
// TODO(JS): May be better to have a ITypeComponent that encapsulates a collection of modules
// For now just add to the linkage
{
SerialContainerData containerData;
SerialContainerUtil::ReadOptions options;
options.namePool = req->getNamePool();
options.session = req->getSession();
options.sharedASTBuilder = linkage->getASTBuilder()->getSharedASTBuilder();
options.sourceManager = linkage->getSourceManager();
options.linkage = req->getLinkage();
options.sink = req->getSink();
SLANG_RETURN_ON_FAIL(SerialContainerUtil::read(&riffContainer, options, containerData));
for (const auto& module : containerData.modules)
{
// If the irModule is set, add it
if (module.irModule)
{
library->m_modules.add(module.irModule);
}
}
for (const auto& entryPoint : containerData.entryPoints)
{
FrontEndCompileRequest::ExtraEntryPointInfo dst;
dst.mangledName = entryPoint.mangledName;
dst.name = entryPoint.name;
dst.profile = entryPoint.profile;
// Add entry point
library->m_entryPoints.add(dst);
}
}
outLibrary.swap(scopeLibrary);
return SLANG_OK;
}
SlangResult loadModuleLibrary(ArtifactKeep keep, IArtifact* artifact, EndToEndCompileRequest* req, ComPtr<IModuleLibrary>& outLibrary)
{
if (auto foundLibrary = findRepresentation<IModuleLibrary>(artifact))
{
outLibrary = foundLibrary;
return SLANG_OK;
}
// Load the blob
ComPtr<ISlangBlob> blob;
SLANG_RETURN_ON_FAIL(artifact->loadBlob(getIntermediateKeep(keep), blob.writeRef()));
// Load the module
ComPtr<IModuleLibrary> library;
SLANG_RETURN_ON_FAIL(loadModuleLibrary((const Byte*)blob->getBufferPointer(), blob->getBufferSize(), req, library));
if (canKeep(keep))
{
artifact->addRepresentation(library);
}
outLibrary.swap(library);
return SLANG_OK;
}
} // namespace Slang
|
