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 "clang/Driver/CommonArgs.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Driver/Job.h"
13#include "llvm/ADT/StringSwitch.h"
14#include "llvm/TargetParser/Triple.h"
15#include <regex>
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 case Triple::EnvironmentType::RootSignature:
66 VersionTuple MinVer(1, 0);
67 VersionTuple MaxVer(1, 2);
68 return MinVer <= Version && Version <= MaxVer;
69 }
70 return false;
71}
72
73std::optional<llvm::Triple> tryParseTriple(StringRef Profile) {
74 // [ps|vs|gs|hs|ds|cs|ms|as]_[major]_[minor]
75 SmallVector<StringRef, 3> Parts;
76 Profile.split(A&: Parts, Separator: "_");
77 if (Parts.size() != 3)
78 return std::nullopt;
79
80 Triple::EnvironmentType Kind =
81 StringSwitch<Triple::EnvironmentType>(Parts[0])
82 .Case(S: "ps", Value: Triple::EnvironmentType::Pixel)
83 .Case(S: "vs", Value: Triple::EnvironmentType::Vertex)
84 .Case(S: "gs", Value: Triple::EnvironmentType::Geometry)
85 .Case(S: "hs", Value: Triple::EnvironmentType::Hull)
86 .Case(S: "ds", Value: Triple::EnvironmentType::Domain)
87 .Case(S: "cs", Value: Triple::EnvironmentType::Compute)
88 .Case(S: "lib", Value: Triple::EnvironmentType::Library)
89 .Case(S: "ms", Value: Triple::EnvironmentType::Mesh)
90 .Case(S: "as", Value: Triple::EnvironmentType::Amplification)
91 .Case(S: "rootsig", Value: Triple::EnvironmentType::RootSignature)
92 .Default(Value: Triple::EnvironmentType::UnknownEnvironment);
93 if (Kind == Triple::EnvironmentType::UnknownEnvironment)
94 return std::nullopt;
95
96 unsigned long long Major = 0;
97 if (llvm::getAsUnsignedInteger(Str: Parts[1], Radix: 0, Result&: Major))
98 return std::nullopt;
99
100 unsigned long long Minor = 0;
101 if (Parts[2] == "x" && Kind == Triple::EnvironmentType::Library)
102 Minor = OfflineLibMinor;
103 else if (llvm::getAsUnsignedInteger(Str: Parts[2], Radix: 0, Result&: Minor))
104 return std::nullopt;
105
106 // Determine DXIL version using the minor version number of Shader
107 // Model version specified in target profile. Prior to decoupling DXIL version
108 // numbering from that of Shader Model DXIL version 1.Y corresponds to SM 6.Y.
109 // E.g., dxilv1.Y-unknown-shadermodelX.Y-hull
110 llvm::Triple T;
111 Triple::SubArchType SubArch = llvm::Triple::NoSubArch;
112 switch (Minor) {
113 case 0:
114 SubArch = llvm::Triple::DXILSubArch_v1_0;
115 break;
116 case 1:
117 SubArch = llvm::Triple::DXILSubArch_v1_1;
118 break;
119 case 2:
120 SubArch = llvm::Triple::DXILSubArch_v1_2;
121 break;
122 case 3:
123 SubArch = llvm::Triple::DXILSubArch_v1_3;
124 break;
125 case 4:
126 SubArch = llvm::Triple::DXILSubArch_v1_4;
127 break;
128 case 5:
129 SubArch = llvm::Triple::DXILSubArch_v1_5;
130 break;
131 case 6:
132 SubArch = llvm::Triple::DXILSubArch_v1_6;
133 break;
134 case 7:
135 SubArch = llvm::Triple::DXILSubArch_v1_7;
136 break;
137 case 8:
138 SubArch = llvm::Triple::DXILSubArch_v1_8;
139 break;
140 case 9:
141 SubArch = llvm::Triple::DXILSubArch_v1_9;
142 break;
143 case 10:
144 SubArch = llvm::Triple::DXILSubArch_v1_10;
145 break;
146 case OfflineLibMinor:
147 // Always consider minor version x as the latest supported DXIL version
148 SubArch = llvm::Triple::LatestDXILSubArch;
149 break;
150 default:
151 // No DXIL Version corresponding to specified Shader Model version found
152 return std::nullopt;
153 }
154 T.setArch(Kind: Triple::ArchType::dxil, SubArch);
155 T.setOSName(Triple::getOSTypeName(Kind: Triple::OSType::ShaderModel).str() +
156 VersionTuple(Major, Minor).getAsString());
157 T.setEnvironment(Kind);
158
159 return T;
160}
161
162std::optional<std::string> tryParseProfile(StringRef Profile) {
163 std::optional<llvm::Triple> MaybeT = tryParseTriple(Profile);
164 if (MaybeT && isLegalShaderModel(T&: *MaybeT))
165 return MaybeT->getTriple();
166 else
167 return std::nullopt;
168}
169
170bool isLegalValidatorVersion(StringRef ValVersionStr, const Driver &D) {
171 VersionTuple Version;
172 if (Version.tryParse(string: ValVersionStr) || Version.getBuild() ||
173 Version.getSubminor() || !Version.getMinor()) {
174 D.Diag(DiagID: diag::err_drv_invalid_format_dxil_validator_version)
175 << ValVersionStr;
176 return false;
177 }
178
179 uint64_t Major = Version.getMajor();
180 uint64_t Minor = *Version.getMinor();
181 if (Major == 0 && Minor != 0) {
182 D.Diag(DiagID: diag::err_drv_invalid_empty_dxil_validator_version) << ValVersionStr;
183 return false;
184 }
185 VersionTuple MinVer(1, 0);
186 if (Version < MinVer) {
187 D.Diag(DiagID: diag::err_drv_invalid_range_dxil_validator_version) << ValVersionStr;
188 return false;
189 }
190 return true;
191}
192
193void getSpirvExtOperand(StringRef SpvExtensionArg, raw_ostream &out) {
194 // The extensions that are commented out are supported in DXC, but the SPIR-V
195 // backend does not know about them yet.
196 static const std::vector<StringRef> DxcSupportedExtensions = {
197 "SPV_KHR_16bit_storage",
198 "SPV_KHR_device_group",
199 "SPV_KHR_fragment_shading_rate",
200 "SPV_KHR_multiview",
201 "SPV_KHR_post_depth_coverage",
202 "SPV_KHR_non_semantic_info",
203 "SPV_KHR_shader_draw_parameters",
204 "SPV_KHR_ray_tracing",
205 "SPV_KHR_shader_clock",
206 "SPV_EXT_demote_to_helper_invocation",
207 "SPV_EXT_descriptor_indexing",
208 "SPV_EXT_fragment_fully_covered",
209 "SPV_EXT_fragment_invocation_density",
210 "SPV_EXT_fragment_shader_interlock",
211 "SPV_EXT_mesh_shader",
212 "SPV_EXT_shader_stencil_export",
213 "SPV_EXT_shader_viewport_index_layer",
214 // "SPV_AMD_shader_early_and_late_fragment_tests",
215 "SPV_GOOGLE_hlsl_functionality1",
216 "SPV_GOOGLE_user_type",
217 "SPV_KHR_ray_query",
218 "SPV_EXT_shader_image_int64",
219 "SPV_KHR_fragment_shader_barycentric",
220 "SPV_KHR_physical_storage_buffer",
221 "SPV_KHR_vulkan_memory_model",
222 // "SPV_KHR_compute_shader_derivatives",
223 "SPV_KHR_maximal_reconvergence",
224 "SPV_KHR_float_controls",
225 "SPV_NV_shader_subgroup_partitioned",
226 // "SPV_KHR_quad_control"
227 };
228
229 if (SpvExtensionArg.starts_with(Prefix: "SPV_")) {
230 out << "+" << SpvExtensionArg;
231 return;
232 }
233
234 if (SpvExtensionArg.compare_insensitive(RHS: "DXC") == 0) {
235 bool first = true;
236 for (StringRef E : DxcSupportedExtensions) {
237 if (!first)
238 out << ",";
239 else
240 first = false;
241 out << "+" << E;
242 }
243 return;
244 }
245 out << SpvExtensionArg;
246}
247
248SmallString<1024> getSpirvExtArg(ArrayRef<std::string> SpvExtensionArgs) {
249 // The backend uses any enabled extension it can, so `all` makes modules
250 // declare extensions that a Vulkan application may not have enabled.
251 const std::string DefaultExtension = "DXC";
252 if (SpvExtensionArgs.empty())
253 SpvExtensionArgs = ArrayRef<std::string>(DefaultExtension);
254
255 llvm::SmallString<1024> LlvmOption;
256 raw_svector_ostream out(LlvmOption);
257
258 out << "-spirv-ext=";
259 getSpirvExtOperand(SpvExtensionArg: SpvExtensionArgs[0], out);
260
261 SpvExtensionArgs = SpvExtensionArgs.slice(N: 1);
262 for (StringRef Extension : SpvExtensionArgs) {
263 out << ",";
264 getSpirvExtOperand(SpvExtensionArg: Extension, out);
265 }
266 return LlvmOption;
267}
268
269bool isValidSPIRVExtensionName(const std::string &str) {
270 std::regex pattern("dxc|DXC|khr|KHR|all|SPV_[a-zA-Z0-9_]+");
271 return std::regex_match(s: str, re: pattern);
272}
273
274// SPIRV extension names are of the form `SPV_[a-zA-Z0-9_]+`. We want to
275// disallow obviously invalid names to avoid issues when parsing `spirv-ext`.
276bool checkExtensionArgsAreValid(ArrayRef<std::string> SpvExtensionArgs,
277 const Driver &Driver) {
278 bool AllValid = true;
279 for (auto Extension : SpvExtensionArgs) {
280 if (!isValidSPIRVExtensionName(str: Extension)) {
281 Driver.Diag(DiagID: diag::err_drv_invalid_value)
282 << "-fspv-extension" << Extension;
283 AllValid = false;
284 }
285 }
286 return AllValid;
287}
288
289bool isRootSignatureTarget(StringRef Profile) {
290 if (std::optional<llvm::Triple> T = tryParseTriple(Profile))
291 return T->getEnvironment() == Triple::EnvironmentType::RootSignature;
292 return false;
293}
294
295bool isRootSignatureTarget(DerivedArgList &Args) {
296 if (const Arg *A = Args.getLastArg(Ids: options::OPT_target_profile))
297 return isRootSignatureTarget(Profile: A->getValue());
298 return false;
299}
300
301} // namespace
302
303void tools::hlsl::Validator::ConstructJob(Compilation &C, const JobAction &JA,
304 const InputInfo &Output,
305 const InputInfoList &Inputs,
306 const ArgList &Args,
307 const char *LinkingOutput) const {
308 ArgStringList CmdArgs;
309 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
310 const InputInfo &Input = Inputs[0];
311
312 const llvm::Triple &T = getToolChain().getTriple();
313 std::string ExecPath;
314 if (T.isSPIRV()) {
315 ExecPath = getToolChain().GetProgramPath(Name: "spirv-val");
316 assert(ExecPath != "spirv-val" && "cannot find spirv-val");
317
318 CmdArgs.push_back(Elt: "--target-env");
319 CmdArgs.push_back(Elt: Args.MakeArgString(Str: T.getOSName()));
320 CmdArgs.push_back(Elt: "--scalar-block-layout");
321 CmdArgs.push_back(Elt: Input.getFilename());
322 } else if (T.isDXIL()) {
323 ExecPath = getToolChain().GetProgramPath(Name: "dxv");
324 assert(ExecPath != "dxv" && "cannot find dxv");
325
326 CmdArgs.push_back(Elt: Input.getFilename());
327 CmdArgs.push_back(Elt: "-o");
328 CmdArgs.push_back(Elt: Output.getFilename());
329 } else {
330 llvm_unreachable("unexpected triple for HLSL validation");
331 }
332
333 const char *Exec = Args.MakeArgString(Str: ExecPath);
334 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
335 args&: Exec, args&: CmdArgs, args: Inputs, args: Input));
336}
337
338void tools::hlsl::MetalConverter::ConstructJob(
339 Compilation &C, const JobAction &JA, const InputInfo &Output,
340 const InputInfoList &Inputs, const ArgList &Args,
341 const char *LinkingOutput) const {
342 std::string MSCPath = getToolChain().GetProgramPath(Name: "metal-shaderconverter");
343 ArgStringList CmdArgs;
344 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
345 const InputInfo &Input = Inputs[0];
346 CmdArgs.push_back(Elt: Input.getFilename());
347 CmdArgs.push_back(Elt: "-o");
348 CmdArgs.push_back(Elt: Output.getFilename());
349
350 StringRef Reflection = Args.getLastArgValue(Id: options::OPT_dxc_Fre);
351 if (!Reflection.empty()) {
352 const char *ReflectionStr =
353 Args.MakeArgString(Str: StringRef("--output-reflection-file=") + Reflection);
354 CmdArgs.push_back(Elt: ReflectionStr);
355 }
356
357 const char *Exec = Args.MakeArgString(Str: MSCPath);
358 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
359 args&: Exec, args&: CmdArgs, args: Inputs, args: Input));
360}
361
362void tools::hlsl::LLVMObjcopy::ConstructJob(Compilation &C, const JobAction &JA,
363 const InputInfo &Output,
364 const InputInfoList &Inputs,
365 const ArgList &Args,
366 const char *LinkingOutput) const {
367
368 std::string ObjcopyPath = getToolChain().GetProgramPath(Name: "llvm-objcopy");
369 const char *Exec = Args.MakeArgString(Str: ObjcopyPath);
370
371 ArgStringList CmdArgs;
372 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
373 const InputInfo &Input = Inputs[0];
374 CmdArgs.push_back(Elt: Input.getFilename());
375 CmdArgs.push_back(Elt: Output.getFilename());
376
377 if (Args.hasArg(Ids: options::OPT_dxc_strip_rootsignature)) {
378 const char *StripRS = Args.MakeArgString(Str: "--remove-section=RTS0");
379 CmdArgs.push_back(Elt: StripRS);
380 }
381
382 if (Arg *Arg = Args.getLastArg(Ids: options::OPT_dxc_Frs)) {
383 const char *Frs =
384 Args.MakeArgString(Str: "--extract-section=RTS0=" + Twine(Arg->getValue()));
385 CmdArgs.push_back(Elt: Frs);
386 }
387
388 if (const Arg *A = Args.getLastArg(Ids: options::OPT_target_profile))
389 if (isRootSignatureTarget(Profile: A->getValue())) {
390 const char *Fos = Args.MakeArgString(Str: "--only-section=RTS0");
391 CmdArgs.push_back(Elt: Fos);
392 }
393
394 assert(CmdArgs.size() > 2 && "Unnecessary invocation of objcopy.");
395
396 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
397 args&: Exec, args&: CmdArgs, args: Inputs, args: Input));
398}
399
400/// DirectX Toolchain
401HLSLToolChain::HLSLToolChain(const Driver &D, const llvm::Triple &Triple,
402 const ArgList &Args)
403 : ToolChain(D, Triple, Args) {
404 if (Args.hasArg(Ids: options::OPT_dxc_validator_path_EQ))
405 getProgramPaths().push_back(
406 Elt: Args.getLastArgValue(Id: options::OPT_dxc_validator_path_EQ).str());
407 if (Args.hasArg(Ids: options::OPT_spirv_validator_path_EQ))
408 getProgramPaths().push_back(
409 Elt: Args.getLastArgValue(Id: options::OPT_spirv_validator_path_EQ).str());
410}
411
412Tool *clang::driver::toolchains::HLSLToolChain::getTool(
413 Action::ActionClass AC) const {
414 switch (AC) {
415 case Action::BinaryAnalyzeJobClass:
416 if (!Validator)
417 Validator.reset(p: new tools::hlsl::Validator(*this));
418 return Validator.get();
419 case Action::BinaryTranslatorJobClass:
420 if (!MetalConverter)
421 MetalConverter.reset(p: new tools::hlsl::MetalConverter(*this));
422 return MetalConverter.get();
423 case Action::ObjcopyJobClass:
424 if (!LLVMObjcopy)
425 LLVMObjcopy.reset(p: new tools::hlsl::LLVMObjcopy(*this));
426 return LLVMObjcopy.get();
427 default:
428 return ToolChain::getTool(AC);
429 }
430}
431
432std::optional<std::string>
433clang::driver::toolchains::HLSLToolChain::parseTargetProfile(
434 StringRef TargetProfile) {
435 return tryParseProfile(Profile: TargetProfile);
436}
437
438DerivedArgList *
439HLSLToolChain::TranslateArgs(const DerivedArgList &Args, BoundArch BA,
440 Action::OffloadKind DeviceOffloadKind) const {
441 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
442
443 const OptTable &Opts = getDriver().getOpts();
444
445 if (Args.hasArg(Ids: options::OPT_dxc_col_major) &&
446 Args.hasArg(Ids: options::OPT_dxc_row_major))
447 getDriver().Diag(DiagID: diag::err_drv_dxc_invalid_matrix_layout);
448
449 if (Args.hasArg(Ids: options::OPT_dxc_pack_prefix_stable) &&
450 Args.hasArg(Ids: options::OPT_dxc_pack_optimized))
451 getDriver().Diag(DiagID: diag::err_drv_argument_not_allowed_with)
452 << "-pack-prefix-stable" << "-pack-optimized";
453
454 for (Arg *A : Args) {
455 if (A->getOption().matches(ID: options::OPT_dxc_pack_prefix_stable) ||
456 A->getOption().matches(ID: options::OPT_dxc_pack_optimized)) {
457 DAL->AddJoinedArg(
458 BaseArg: nullptr,
459 Opt: Opts.getOption(Opt: options::OPT_fdx_semantic_signature_packing_mode_EQ),
460 Value: A->getOption().matches(ID: options::OPT_dxc_pack_prefix_stable)
461 ? "prefix-stable"
462 : "optimized");
463 A->claim();
464 continue;
465 }
466 if (A->getOption().getID() == options::OPT_dxc_all_resources_bound) {
467 DAL->AddFlagArg(BaseArg: nullptr,
468 Opt: Opts.getOption(Opt: options::OPT_hlsl_all_resources_bound));
469 A->claim();
470 continue;
471 }
472 if (A->getOption().getID() == options::OPT_dxil_validator_version) {
473 StringRef ValVerStr = A->getValue();
474 if (!isLegalValidatorVersion(ValVersionStr: ValVerStr, D: getDriver()))
475 continue;
476 }
477 if (A->getOption().getID() == options::OPT_dxc_entrypoint) {
478 DAL->AddSeparateArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_hlsl_entrypoint),
479 Value: A->getValue());
480 A->claim();
481 continue;
482 }
483 if (A->getOption().getID() == options::OPT_dxc_rootsig_ver) {
484 DAL->AddJoinedArg(BaseArg: nullptr,
485 Opt: Opts.getOption(Opt: options::OPT_fdx_rootsignature_version),
486 Value: A->getValue());
487 A->claim();
488 continue;
489 }
490 if (A->getOption().getID() == options::OPT_dxc_rootsig_define) {
491 DAL->AddJoinedArg(BaseArg: nullptr,
492 Opt: Opts.getOption(Opt: options::OPT_fdx_rootsignature_define),
493 Value: A->getValue());
494 A->claim();
495 continue;
496 }
497 if (A->getOption().getID() == options::OPT__SLASH_O) {
498 StringRef OStr = A->getValue();
499 if (OStr == "d") {
500 DAL->AddFlagArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_O0));
501 A->claim();
502 continue;
503 } else {
504 DAL->AddJoinedArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_O), Value: OStr);
505 A->claim();
506 continue;
507 }
508 }
509 if (A->getOption().getID() == options::OPT_emit_pristine_llvm) {
510 // Translate -fcgl into -emit-llvm and -disable-llvm-passes.
511 DAL->AddFlagArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_emit_llvm));
512 DAL->AddFlagArg(BaseArg: nullptr,
513 Opt: Opts.getOption(Opt: options::OPT_disable_llvm_passes));
514 A->claim();
515 continue;
516 }
517 if (A->getOption().getID() == options::OPT_dxc_hlsl_version) {
518 // Translate -HV into -std for llvm
519 // depending on the value given
520 LangStandard::Kind LangStd = LangStandard::getHLSLLangKind(Name: A->getValue());
521 if (LangStd != LangStandard::lang_unspecified) {
522 LangStandard l = LangStandard::getLangStandardForKind(K: LangStd);
523 DAL->AddSeparateArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_std_EQ),
524 Value: l.getName());
525 } else {
526 getDriver().Diag(DiagID: diag::err_drv_invalid_value) << "HV" << A->getValue();
527 }
528
529 A->claim();
530 continue;
531 }
532 if (A->getOption().getID() == options::OPT_dxc_gis) {
533 // Translate -Gis into -ffp_model_EQ=strict
534 DAL->AddSeparateArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_ffp_model_EQ),
535 Value: "strict");
536 A->claim();
537 continue;
538 }
539 if (A->getOption().getID() == options::OPT_fvk_use_dx_layout) {
540 // This is the only implemented layout so far.
541 A->claim();
542 continue;
543 }
544
545 if (A->getOption().getID() == options::OPT_fvk_use_scalar_layout) {
546 getDriver().Diag(DiagID: diag::err_drv_clang_unsupported) << A->getAsString(Args);
547 A->claim();
548 continue;
549 }
550
551 if (A->getOption().getID() == options::OPT_fvk_use_gl_layout) {
552 getDriver().Diag(DiagID: diag::err_drv_clang_unsupported) << A->getAsString(Args);
553 A->claim();
554 continue;
555 }
556
557 if ((A->getOption().getID() ==
558 options::OPT_fhlsl_spv_use_legacy_buffer_matrix_order ||
559 A->getOption().getID() ==
560 options::OPT_fhlsl_spv_support_nonzero_base_instance) &&
561 getArch() != llvm::Triple::spirv) {
562 getDriver().Diag(DiagID: diag::err_drv_argument_only_allowed_with)
563 << A->getAsString(Args) << "-spirv";
564 A->claim();
565 continue;
566 }
567
568 if (A->getOption().getID() == options::OPT_enable_16bit_types) {
569 // Translate -enable-16bit-types into -fnative-half-type and
570 // -fnative-int16-type
571 DAL->AddFlagArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_fnative_half_type));
572 DAL->AddFlagArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_fnative_int16_type));
573 A->claim();
574 continue;
575 }
576 if (A->getOption().getID() == options::OPT_dxc_col_major) {
577 DAL->AddJoinedArg(BaseArg: nullptr,
578 Opt: Opts.getOption(Opt: options::OPT_fmatrix_memory_layout_EQ),
579 Value: "column-major");
580 A->claim();
581 continue;
582 }
583 if (A->getOption().getID() == options::OPT_dxc_row_major) {
584 DAL->AddJoinedArg(BaseArg: nullptr,
585 Opt: Opts.getOption(Opt: options::OPT_fmatrix_memory_layout_EQ),
586 Value: "row-major");
587 A->claim();
588 continue;
589 }
590
591 // This is a temporary check until we support reflection generation for
592 // other targets.
593 if (A->getOption().getID() == options::OPT_dxc_Fre) {
594 if (Args.hasArg(Ids: options::OPT_metal)) {
595 if (!Args.hasArg(Ids: options::OPT_dxc_Fo))
596 getDriver().Diag(DiagID: diag::err_drv_dxc_Fre_requires_Fo_metal);
597 } else
598 getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
599 << "-Fre" << getTriple().getArchName();
600 A->claim();
601 DAL->AddSeparateArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_dxc_Fre),
602 Value: A->getValue());
603 continue;
604 }
605
606 DAL->append(A);
607 }
608
609 if (getArch() == llvm::Triple::spirv) {
610 std::vector<std::string> SpvExtensionArgs =
611 Args.getAllArgValues(Id: options::OPT_fspv_extension_EQ);
612 if (checkExtensionArgsAreValid(SpvExtensionArgs, Driver: getDriver())) {
613 SmallString<1024> LlvmOption = getSpirvExtArg(SpvExtensionArgs);
614 DAL->AddSeparateArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_mllvm),
615 Value: LlvmOption);
616 }
617 Args.claimAllArgs(Ids: options::OPT_fspv_extension_EQ);
618 }
619
620 if (!DAL->hasArg(Ids: options::OPT_O_Group)) {
621 DAL->AddJoinedArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_O), Value: "3");
622 }
623
624 return DAL;
625}
626
627HLSLToolChain::ValidationInfo
628HLSLToolChain::getValidationInfo(DerivedArgList &Args, bool Diagnose) const {
629 ValidationInfo Info;
630
631 bool HasFo = Args.hasArg(Ids: options::OPT_dxc_Fo);
632 bool DisableValidation =
633 Args.getLastArg(Ids: options::OPT_dxc_disable_validation) != nullptr;
634
635 if (DisableValidation || !HasFo)
636 return Info;
637
638 if (getTriple().isDXIL()) {
639 std::string DxvPath = GetProgramPath(Name: "dxv");
640 if (DxvPath != "dxv") {
641 Info.NeedsValidation = true;
642 Info.ProducesOutput = true;
643 return Info;
644 }
645
646 if (Diagnose)
647 getDriver().Diag(DiagID: diag::warn_drv_dxc_missing_dxv);
648 return Info;
649 }
650
651 if (getTriple().isSPIRV()) {
652 std::string SpirvValPath = GetProgramPath(Name: "spirv-val");
653 if (SpirvValPath != "spirv-val") {
654 Info.NeedsValidation = true;
655 Info.ProducesOutput = false;
656 return Info;
657 }
658
659 if (Diagnose)
660 getDriver().Diag(DiagID: diag::warn_drv_dxc_missing_spirv_val);
661 }
662
663 return Info;
664}
665
666bool HLSLToolChain::requiresBinaryTranslation(DerivedArgList &Args) const {
667 return Args.hasArg(Ids: options::OPT_metal) && Args.hasArg(Ids: options::OPT_dxc_Fo);
668}
669
670bool HLSLToolChain::requiresObjcopy(DerivedArgList &Args) const {
671 return Args.hasArg(Ids: options::OPT_dxc_Fo) &&
672 (Args.hasArg(Ids: options::OPT_dxc_strip_rootsignature) ||
673 Args.hasArg(Ids: options::OPT_dxc_Frs) || isRootSignatureTarget(Args));
674}
675
676bool HLSLToolChain::isLastOutputProducingJob(DerivedArgList &Args,
677 Action::ActionClass AC) const {
678 // Note: we check in the reverse order of execution
679 if (requiresBinaryTranslation(Args))
680 return AC == Action::Action::BinaryTranslatorJobClass;
681 auto ValInfo = getValidationInfo(Args, /*Diagnose=*/false);
682 if (ValInfo.NeedsValidation) {
683 if (ValInfo.ProducesOutput)
684 return AC == Action::Action::BinaryAnalyzeJobClass;
685 return AC == Action::Action::AssembleJobClass;
686 }
687 if (requiresObjcopy(Args))
688 return AC == Action::Action::ObjcopyJobClass;
689
690 // No translation, validation, or objcopy are required, so this action must
691 // output to the result file.
692 return true;
693}
694
695void HLSLToolChain::addClangWarningOptions(ArgStringList &CC1Args) const {
696 CC1Args.push_back(Elt: "-Wconversion");
697 CC1Args.push_back(Elt: "-Wvector-conversion");
698 CC1Args.push_back(Elt: "-Wmatrix-conversion");
699}
700