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
|
#include "slang-metal-compiler.h"
#include "slang-gcc-compiler-util.h"
#include "slang-artifact-desc-util.h"
#include "slang-artifact-util.h"
#include "slang-artifact-representation.h"
namespace Slang
{
class MetalDownstreamCompiler : public DownstreamCompilerBase
{
public:
// Because the metal compiler shares the same commandline interface with clang,
// we will use GccDownstreamCompilerUtil, which implements both gcc and clang,
// to create the inner compiler and wrap it here.
//
ComPtr<IDownstreamCompiler> cppCompiler;
String executablePath;
MetalDownstreamCompiler(ComPtr<IDownstreamCompiler>& innerCompiler, String path)
: DownstreamCompilerBase(innerCompiler->getDesc())
, cppCompiler(innerCompiler)
, executablePath(path)
{
}
virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() override { return true; }
virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outArtifact) override
{
// All compile requests should be routed directly to the inner compiler.
return cppCompiler->compile(options, outArtifact);
}
virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) override
{
// Report that we can convert Metal IR to disassembly.
return ArtifactDescUtil::isDisassembly(from, to) && from.payload == ArtifactPayload::MetalAIR;
}
virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) override
{
// Use metal-objdump to disassemble the Metal IR.
ExecutableLocation exeLocation(executablePath, "metal-objdump");
CommandLine cmdLine;
cmdLine.setExecutableLocation(exeLocation);
cmdLine.addArg("--disassemble");
ComPtr<IOSFileArtifactRepresentation> srcFile;
SLANG_RETURN_ON_FAIL(from->requireFile(IArtifact::Keep::No, srcFile.writeRef()));
cmdLine.addArg(String(srcFile->getPath()));
ExecuteResult exeRes;
SLANG_RETURN_ON_FAIL(ProcessUtil::execute(cmdLine, exeRes));
auto artifact = ArtifactUtil::createArtifact(to);
artifact->addRepresentationUnknown(StringBlob::create(exeRes.standardOutput));
*outArtifact = artifact.detach();
return SLANG_OK;
}
};
static SlangResult locateMetalCompiler(const String& path, DownstreamCompilerSet* set)
{
ComPtr<IDownstreamCompiler> innerCppCompiler;
ExecutableLocation exeLocation(path, "metal");
SLANG_RETURN_ON_FAIL(GCCDownstreamCompilerUtil::createCompiler(exeLocation, innerCppCompiler));
ComPtr<IDownstreamCompiler> compiler = ComPtr<IDownstreamCompiler>(
new MetalDownstreamCompiler(innerCppCompiler, path));
set->addCompiler(compiler);
return SLANG_OK;
}
SlangResult MetalDownstreamCompilerUtil::locateCompilers(const String& path, ISlangSharedLibraryLoader* loader, DownstreamCompilerSet* set)
{
SLANG_UNUSED(loader);
return locateMetalCompiler(path, set);
}
}
|
