clang 19.0.0git
HLSL.cpp
Go to the documentation of this file.
1//===--- HLSL.cpp - HLSL ToolChain Implementations --------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "HLSL.h"
10#include "CommonArgs.h"
13#include "clang/Driver/Job.h"
14#include "llvm/ADT/StringSwitch.h"
15#include "llvm/TargetParser/Triple.h"
16
17using namespace clang::driver;
18using namespace clang::driver::tools;
19using namespace clang::driver::toolchains;
20using namespace clang;
21using namespace llvm::opt;
22using namespace llvm;
23
24namespace {
25
26const unsigned OfflineLibMinor = 0xF;
27
28bool isLegalShaderModel(Triple &T) {
29 if (T.getOS() != Triple::OSType::ShaderModel)
30 return false;
31
32 auto Version = T.getOSVersion();
33 if (Version.getBuild())
34 return false;
35 if (Version.getSubminor())
36 return false;
37
38 auto Kind = T.getEnvironment();
39
40 switch (Kind) {
41 default:
42 return false;
43 case Triple::EnvironmentType::Vertex:
44 case Triple::EnvironmentType::Hull:
45 case Triple::EnvironmentType::Domain:
46 case Triple::EnvironmentType::Geometry:
47 case Triple::EnvironmentType::Pixel:
48 case Triple::EnvironmentType::Compute: {
49 VersionTuple MinVer(4, 0);
50 return MinVer <= Version;
51 } break;
52 case Triple::EnvironmentType::Library: {
53 VersionTuple SM6x(6, OfflineLibMinor);
54 if (Version == SM6x)
55 return true;
56
57 VersionTuple MinVer(6, 3);
58 return MinVer <= Version;
59 } break;
60 case Triple::EnvironmentType::Amplification:
61 case Triple::EnvironmentType::Mesh: {
62 VersionTuple MinVer(6, 5);
63 return MinVer <= Version;
64 } break;
65 }
66 return false;
67}
68
69std::optional<std::string> tryParseProfile(StringRef Profile) {
70 // [ps|vs|gs|hs|ds|cs|ms|as]_[major]_[minor]
72 Profile.split(Parts, "_");
73 if (Parts.size() != 3)
74 return std::nullopt;
75
76 Triple::EnvironmentType Kind =
77 StringSwitch<Triple::EnvironmentType>(Parts[0])
78 .Case("ps", Triple::EnvironmentType::Pixel)
79 .Case("vs", Triple::EnvironmentType::Vertex)
80 .Case("gs", Triple::EnvironmentType::Geometry)
81 .Case("hs", Triple::EnvironmentType::Hull)
82 .Case("ds", Triple::EnvironmentType::Domain)
83 .Case("cs", Triple::EnvironmentType::Compute)
84 .Case("lib", Triple::EnvironmentType::Library)
85 .Case("ms", Triple::EnvironmentType::Mesh)
86 .Case("as", Triple::EnvironmentType::Amplification)
87 .Default(Triple::EnvironmentType::UnknownEnvironment);
88 if (Kind == Triple::EnvironmentType::UnknownEnvironment)
89 return std::nullopt;
90
91 unsigned long long Major = 0;
92 if (llvm::getAsUnsignedInteger(Parts[1], 0, Major))
93 return std::nullopt;
94
95 unsigned long long Minor = 0;
96 if (Parts[2] == "x" && Kind == Triple::EnvironmentType::Library)
97 Minor = OfflineLibMinor;
98 else if (llvm::getAsUnsignedInteger(Parts[2], 0, Minor))
99 return std::nullopt;
100
101 // dxil-unknown-shadermodel-hull
102 llvm::Triple T;
103 T.setArch(Triple::ArchType::dxil);
104 T.setOSName(Triple::getOSTypeName(Triple::OSType::ShaderModel).str() +
105 VersionTuple(Major, Minor).getAsString());
106 T.setEnvironment(Kind);
107 if (isLegalShaderModel(T))
108 return T.getTriple();
109 else
110 return std::nullopt;
111}
112
113bool isLegalValidatorVersion(StringRef ValVersionStr, const Driver &D) {
114 VersionTuple Version;
115 if (Version.tryParse(ValVersionStr) || Version.getBuild() ||
116 Version.getSubminor() || !Version.getMinor()) {
117 D.Diag(diag::err_drv_invalid_format_dxil_validator_version)
118 << ValVersionStr;
119 return false;
120 }
121
122 uint64_t Major = Version.getMajor();
123 uint64_t Minor = *Version.getMinor();
124 if (Major == 0 && Minor != 0) {
125 D.Diag(diag::err_drv_invalid_empty_dxil_validator_version) << ValVersionStr;
126 return false;
127 }
128 VersionTuple MinVer(1, 0);
129 if (Version < MinVer) {
130 D.Diag(diag::err_drv_invalid_range_dxil_validator_version) << ValVersionStr;
131 return false;
132 }
133 return true;
134}
135
136} // namespace
137
139 const InputInfo &Output,
140 const InputInfoList &Inputs,
141 const ArgList &Args,
142 const char *LinkingOutput) const {
143 std::string DxvPath = getToolChain().GetProgramPath("dxv");
144 assert(DxvPath != "dxv" && "cannot find dxv");
145
146 ArgStringList CmdArgs;
147 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
148 const InputInfo &Input = Inputs[0];
149 assert(Input.isFilename() && "Unexpected verify input");
150 // Grabbing the output of the earlier cc1 run.
151 CmdArgs.push_back(Input.getFilename());
152 // Use the same name as output.
153 CmdArgs.push_back("-o");
154 CmdArgs.push_back(Input.getFilename());
155
156 const char *Exec = Args.MakeArgString(DxvPath);
157 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
158 Exec, CmdArgs, Inputs, Input));
159}
160
161/// DirectX Toolchain
162HLSLToolChain::HLSLToolChain(const Driver &D, const llvm::Triple &Triple,
163 const ArgList &Args)
164 : ToolChain(D, Triple, Args) {
165 if (Args.hasArg(options::OPT_dxc_validator_path_EQ))
166 getProgramPaths().push_back(
167 Args.getLastArgValue(options::OPT_dxc_validator_path_EQ).str());
168}
169
171 Action::ActionClass AC) const {
172 switch (AC) {
174 if (!Validator)
175 Validator.reset(new tools::hlsl::Validator(*this));
176 return Validator.get();
177 default:
178 return ToolChain::getTool(AC);
179 }
180}
181
182std::optional<std::string>
184 StringRef TargetProfile) {
185 return tryParseProfile(TargetProfile);
186}
187
188DerivedArgList *
189HLSLToolChain::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
190 Action::OffloadKind DeviceOffloadKind) const {
191 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
192
193 const OptTable &Opts = getDriver().getOpts();
194
195 for (Arg *A : Args) {
196 if (A->getOption().getID() == options::OPT_dxil_validator_version) {
197 StringRef ValVerStr = A->getValue();
198 std::string ErrorMsg;
199 if (!isLegalValidatorVersion(ValVerStr, getDriver()))
200 continue;
201 }
202 if (A->getOption().getID() == options::OPT_dxc_entrypoint) {
203 DAL->AddSeparateArg(nullptr, Opts.getOption(options::OPT_hlsl_entrypoint),
204 A->getValue());
205 A->claim();
206 continue;
207 }
208 if (A->getOption().getID() == options::OPT__SLASH_O) {
209 StringRef OStr = A->getValue();
210 if (OStr == "d") {
211 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_O0));
212 A->claim();
213 continue;
214 } else {
215 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_O), OStr);
216 A->claim();
217 continue;
218 }
219 }
220 if (A->getOption().getID() == options::OPT_emit_pristine_llvm) {
221 // Translate fcgl into -S -emit-llvm and -disable-llvm-passes.
222 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_S));
223 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_emit_llvm));
224 DAL->AddFlagArg(nullptr,
225 Opts.getOption(options::OPT_disable_llvm_passes));
226 A->claim();
227 continue;
228 }
229 DAL->append(A);
230 }
231
232 // Add default validator version if not set.
233 // TODO: remove this once read validator version from validator.
234 if (!DAL->hasArg(options::OPT_dxil_validator_version)) {
235 const StringRef DefaultValidatorVer = "1.7";
236 DAL->AddSeparateArg(nullptr,
237 Opts.getOption(options::OPT_dxil_validator_version),
238 DefaultValidatorVer);
239 }
240 if (!DAL->hasArg(options::OPT_O_Group)) {
241 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_O), "3");
242 }
243 // FIXME: add validation for enable_16bit_types should be after HLSL 2018 and
244 // shader model 6.2.
245 // See: https://github.com/llvm/llvm-project/issues/57876
246 return DAL;
247}
248
249bool HLSLToolChain::requiresValidation(DerivedArgList &Args) const {
250 if (Args.getLastArg(options::OPT_dxc_disable_validation))
251 return false;
252
253 std::string DxvPath = GetProgramPath("dxv");
254 if (DxvPath != "dxv")
255 return true;
256
257 getDriver().Diag(diag::warn_drv_dxc_missing_dxv);
258 return false;
259}
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:144
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:402
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
const char * getFilename() const
Definition: InputInfo.h:83
bool isFilename() const
Definition: InputInfo.h:75
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:92
const Driver & getDriver() const
Definition: ToolChain.h:252
path_list & getProgramPaths()
Definition: ToolChain.h:297
std::string GetProgramPath(const char *Name) const
Definition: ToolChain.cpp:854
virtual Tool * getTool(Action::ActionClass AC) const
Definition: ToolChain.cpp:534
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
const ToolChain & getToolChain() const
Definition: Tool.h:52
Tool * getTool(Action::ActionClass AC) const override
Definition: HLSL.cpp:170
HLSLToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
DirectX Toolchain.
Definition: HLSL.cpp:162
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: HLSL.cpp:189
bool requiresValidation(llvm::opt::DerivedArgList &Args) const
Definition: HLSL.cpp:249
static std::optional< std::string > parseTargetProfile(StringRef TargetProfile)
Definition: HLSL.cpp:183
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: HLSL.cpp:138
The JSON file list parser is used to communicate input to InstallAPI.
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:60
unsigned long uint64_t
YAML serialization mapping.
Definition: Dominators.h:30
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
Definition: Job.h:78