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
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// slang-module-library.cpp
#include "slang-module-library.h"
#include "../core/slang-blob.h"
#include "../core/slang-riff.h"
#include "../core/slang-type-text-util.h"
#include <assert.h>
// Serialization
#include "slang-serialize-container.h"
#include "slang-serialize-ir.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(
ISlangBlob* blobHoldingSerializedData,
const Byte* inData,
size_t dataSize,
String path,
EndToEndCompileRequest* req,
ComPtr<IModuleLibrary>& outLibrary)
{
SLANG_UNUSED(path);
auto library = new ModuleLibrary;
ComPtr<IModuleLibrary> scopeLibrary(library);
// Load up the module
auto rootChunk = RIFF::RootChunk::getFromBlob(inData, dataSize);
if (!rootChunk)
{
return SLANG_FAIL;
}
auto linkage = req->getLinkage();
auto sink = req->getSink();
auto namePool = req->getNamePool();
auto container = ContainerChunk::find(rootChunk);
if (!container)
{
return SLANG_FAIL;
}
for (auto moduleChunk : container->getModules())
{
auto loadedModule = linkage->findOrLoadSerializedModuleForModuleLibrary(
blobHoldingSerializedData,
moduleChunk,
container,
sink);
if (!loadedModule)
return SLANG_FAIL;
library->m_modules.add(loadedModule);
}
for (auto entryPointChunk : container->getEntryPoints())
{
FrontEndCompileRequest::ExtraEntryPointInfo entryPointInfo;
entryPointInfo.mangledName = entryPointChunk->getMangledName();
entryPointInfo.name = namePool->getName(entryPointChunk->getName());
entryPointInfo.profile = entryPointChunk->getProfile();
library->m_entryPoints.add(entryPointInfo);
}
outLibrary.swap(scopeLibrary);
return SLANG_OK;
}
SlangResult loadModuleLibrary(
ArtifactKeep keep,
IArtifact* artifact,
String path,
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(
blob,
(const Byte*)blob->getBufferPointer(),
blob->getBufferSize(),
path,
req,
library));
if (canKeep(keep))
{
artifact->addRepresentation(library);
}
outLibrary.swap(library);
return SLANG_OK;
}
} // namespace Slang
|
