11#include "clang/Config/config.h"
18#include "llvm/Config/llvm-config.h"
19#include "llvm/Option/ArgList.h"
20#include "llvm/Support/FileSystem.h"
21#include "llvm/Support/Path.h"
22#include "llvm/Support/VirtualFileSystem.h"
23#include <system_error>
35 const char *LinkingOutput)
const {
37 ArgStringList CmdArgs;
40 CmdArgs.push_back(
"--32");
41 }
else if (
getToolChain().getArch() == llvm::Triple::x86_64) {
42 CmdArgs.push_back(
"--64");
45 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
47 CmdArgs.push_back(
"-o");
50 for (
const auto &II : Inputs)
51 CmdArgs.push_back(II.getFilename());
53 const char *Exec = Args.MakeArgString(
getToolChain().GetProgramPath(
"as"));
55 Exec, CmdArgs, Inputs, Output));
57 if (Args.hasArg(options::OPT_gsplit_dwarf))
62void tools::MinGW::Linker::AddLibGCC(
const ArgList &Args,
63 ArgStringList &CmdArgs)
const {
64 if (Args.hasArg(options::OPT_mthreads))
65 CmdArgs.push_back(
"-lmingwthrd");
66 CmdArgs.push_back(
"-lmingw32");
71 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
72 Args.hasArg(options::OPT_static);
73 bool Shared = Args.hasArg(options::OPT_shared);
74 bool CXX = getToolChain().getDriver().CCCIsCXX();
77 CmdArgs.push_back(
"-lgcc");
78 CmdArgs.push_back(
"-lgcc_eh");
80 CmdArgs.push_back(
"-lgcc_s");
81 CmdArgs.push_back(
"-lgcc");
84 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
87 CmdArgs.push_back(
"-lmoldname");
88 CmdArgs.push_back(
"-lmingwex");
89 for (
auto Lib : Args.getAllArgValues(options::OPT_l))
90 if (StringRef(Lib).starts_with(
"msvcr") ||
91 StringRef(Lib).starts_with(
"ucrt") ||
92 StringRef(Lib).starts_with(
"crtdll"))
94 CmdArgs.push_back(
"-lmsvcrt");
101 const char *LinkingOutput)
const {
106 ArgStringList CmdArgs;
109 Args.ClaimAllArgs(options::OPT_g_Group);
111 Args.ClaimAllArgs(options::OPT_emit_llvm);
114 Args.ClaimAllArgs(options::OPT_w);
116 if (!
D.SysRoot.empty())
117 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" +
D.SysRoot));
119 if (Args.hasArg(options::OPT_s))
120 CmdArgs.push_back(
"-s");
122 CmdArgs.push_back(
"-m");
124 case llvm::Triple::x86:
125 CmdArgs.push_back(
"i386pe");
127 case llvm::Triple::x86_64:
128 CmdArgs.push_back(
"i386pep");
130 case llvm::Triple::arm:
131 case llvm::Triple::thumb:
133 CmdArgs.push_back(
"thumb2pe");
135 case llvm::Triple::aarch64:
137 CmdArgs.push_back(
"arm64ecpe");
139 CmdArgs.push_back(
"arm64pe");
141 case llvm::Triple::mipsel:
142 CmdArgs.push_back(
"mipspe");
149 Args.getLastArg(options::OPT_mwindows, options::OPT_mconsole);
150 if (SubsysArg && SubsysArg->getOption().matches(options::OPT_mwindows)) {
151 CmdArgs.push_back(
"--subsystem");
152 CmdArgs.push_back(
"windows");
153 }
else if (SubsysArg &&
154 SubsysArg->getOption().matches(options::OPT_mconsole)) {
155 CmdArgs.push_back(
"--subsystem");
156 CmdArgs.push_back(
"console");
159 if (Args.hasArg(options::OPT_mdll))
160 CmdArgs.push_back(
"--dll");
161 else if (Args.hasArg(options::OPT_shared))
162 CmdArgs.push_back(
"--shared");
163 if (Args.hasArg(options::OPT_static))
164 CmdArgs.push_back(
"-Bstatic");
166 CmdArgs.push_back(
"-Bdynamic");
167 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
168 CmdArgs.push_back(
"-e");
169 if (TC.
getArch() == llvm::Triple::x86)
170 CmdArgs.push_back(
"_DllMainCRTStartup@12");
172 CmdArgs.push_back(
"DllMainCRTStartup");
173 CmdArgs.push_back(
"--enable-auto-image-base");
176 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
177 CmdArgs.push_back(
"--no-demangle");
179 if (!Args.hasFlag(options::OPT_fauto_import, options::OPT_fno_auto_import,
181 CmdArgs.push_back(
"--disable-auto-import");
183 if (Arg *A = Args.getLastArg(options::OPT_mguard_EQ)) {
184 StringRef GuardArgs = A->getValue();
185 if (GuardArgs ==
"none")
186 CmdArgs.push_back(
"--no-guard-cf");
187 else if (GuardArgs ==
"cf" || GuardArgs ==
"cf-nochecks")
188 CmdArgs.push_back(
"--guard-cf");
190 D.Diag(diag::err_drv_unsupported_option_argument)
191 << A->getSpelling() << GuardArgs;
194 if (Args.hasArg(options::OPT_fms_hotpatch))
195 CmdArgs.push_back(
"--functionpadmin");
197 CmdArgs.push_back(
"-o");
203 if (!llvm::sys::path::has_extension(OutputFile)) {
204 CmdArgs.push_back(Args.MakeArgString(Twine(OutputFile) +
".exe"));
205 OutputFile = CmdArgs.back();
207 CmdArgs.push_back(OutputFile);
210 Args.AddLastArg(CmdArgs, options::OPT_r);
211 Args.AddLastArg(CmdArgs, options::OPT_s);
212 Args.AddLastArg(CmdArgs, options::OPT_t);
213 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
218 if (Sanitize.
needsAsanRt() && !Args.hasArg(options::OPT_nostdlib) &&
219 !Args.hasArg(options::OPT_nodefaultlibs)) {
225 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
226 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
227 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"dllcrt2.o")));
229 if (Args.hasArg(options::OPT_municode))
230 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2u.o")));
232 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2.o")));
234 if (Args.hasArg(options::OPT_pg))
235 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"gcrt2.o")));
236 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtbegin.o")));
239 Args.AddAllArgs(CmdArgs, options::OPT_L);
245 if (TC.
getVFS().exists(LibPath))
246 CmdArgs.push_back(Args.MakeArgString(
"-L" + LibPath));
249 if (TC.
getVFS().exists(CRTPath))
250 CmdArgs.push_back(Args.MakeArgString(
"-L" + CRTPath));
254 if (
D.isUsingLTO()) {
255 assert(!Inputs.empty() &&
"Must have at least one input.");
260 if (
C.getDriver().IsFlangMode() &&
261 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
269 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
270 !Args.hasArg(options::OPT_static);
271 if (OnlyLibstdcxxStatic)
272 CmdArgs.push_back(
"-Bstatic");
274 if (OnlyLibstdcxxStatic)
275 CmdArgs.push_back(
"-Bdynamic");
278 bool HasWindowsApp =
false;
279 for (
auto Lib : Args.getAllArgValues(options::OPT_l)) {
280 if (Lib ==
"windowsapp") {
281 HasWindowsApp =
true;
286 if (!Args.hasArg(options::OPT_nostdlib)) {
287 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
288 if (Args.hasArg(options::OPT_static))
289 CmdArgs.push_back(
"--start-group");
291 if (Args.hasArg(options::OPT_fstack_protector) ||
292 Args.hasArg(options::OPT_fstack_protector_strong) ||
293 Args.hasArg(options::OPT_fstack_protector_all)) {
294 CmdArgs.push_back(
"-lssp_nonshared");
295 CmdArgs.push_back(
"-lssp");
298 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
299 options::OPT_fno_openmp,
false)) {
302 CmdArgs.push_back(
"-lomp");
305 CmdArgs.push_back(
"-liomp5md");
308 CmdArgs.push_back(
"-lgomp");
316 AddLibGCC(Args, CmdArgs);
318 if (Args.hasArg(options::OPT_pg))
319 CmdArgs.push_back(
"-lgmon");
321 if (Args.hasArg(options::OPT_pthread))
322 CmdArgs.push_back(
"-lpthread");
330 CmdArgs.push_back(
"--require-defined");
331 CmdArgs.push_back(TC.
getArch() == llvm::Triple::x86
332 ?
"___asan_seh_interceptor"
333 :
"__asan_seh_interceptor");
336 CmdArgs.push_back(
"--whole-archive");
339 CmdArgs.push_back(
"--no-whole-archive");
344 if (!HasWindowsApp) {
348 if (Args.hasArg(options::OPT_mwindows)) {
349 CmdArgs.push_back(
"-lgdi32");
350 CmdArgs.push_back(
"-lcomdlg32");
352 CmdArgs.push_back(
"-ladvapi32");
353 CmdArgs.push_back(
"-lshell32");
354 CmdArgs.push_back(
"-luser32");
355 CmdArgs.push_back(
"-lkernel32");
358 if (Args.hasArg(options::OPT_static)) {
359 CmdArgs.push_back(
"--end-group");
361 AddLibGCC(Args, CmdArgs);
363 CmdArgs.push_back(
"-lkernel32");
367 if (!Args.hasArg(options::OPT_nostartfiles)) {
371 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtend.o")));
375 C.addCommand(std::make_unique<Command>(JA, *
this,
377 Exec, CmdArgs, Inputs, Output));
381 llvm::Triple HostTriple(llvm::Triple::normalize(LLVM_HOST_TRIPLE));
382 if (HostTriple.getOS() != llvm::Triple::Win32)
384 if (RequireArchMatch && HostTriple.getArch() !=
T.getArch())
395 for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;
396 LI = LI.increment(EC)) {
397 StringRef VersionText = llvm::sys::path::filename(LI->path());
398 auto CandidateVersion =
400 if (CandidateVersion.Major == -1)
402 if (CandidateVersion <= Version)
404 Version = CandidateVersion;
405 Ver = std::string(VersionText);
406 GccLibDir = LI->path();
412 llvm::Triple LiteralTriple(
D.getTargetTriple());
414 LiteralTriple.setArchName(
T.getArchName());
415 return LiteralTriple;
418void toolchains::MinGW::findGccLibDir(
const llvm::Triple &LiteralTriple) {
420 SubdirNames.emplace_back(LiteralTriple.str());
421 SubdirNames.emplace_back(getTriple().str());
422 SubdirNames.emplace_back(getTriple().getArchName());
423 SubdirNames.back() +=
"-w64-mingw32";
424 SubdirNames.emplace_back(getTriple().getArchName());
425 SubdirNames.back() +=
"-w64-mingw32ucrt";
426 SubdirNames.emplace_back(
"mingw32");
427 if (SubdirName.empty()) {
428 SubdirName = getTriple().getArchName();
429 SubdirName +=
"-w64-mingw32";
433 for (StringRef CandidateLib : {
"lib",
"lib64"}) {
434 for (StringRef CandidateSysroot : SubdirNames) {
436 llvm::sys::path::append(LibDir, CandidateLib,
"gcc", CandidateSysroot);
438 SubdirName = std::string(CandidateSysroot);
445static llvm::ErrorOr<std::string>
findGcc(
const llvm::Triple &LiteralTriple,
446 const llvm::Triple &
T) {
448 Gccs.emplace_back(LiteralTriple.str());
449 Gccs.back() +=
"-gcc";
450 Gccs.emplace_back(
T.str());
451 Gccs.back() +=
"-gcc";
452 Gccs.emplace_back(
T.getArchName());
453 Gccs.back() +=
"-w64-mingw32-gcc";
454 Gccs.emplace_back(
T.getArchName());
455 Gccs.back() +=
"-w64-mingw32ucrt-gcc";
456 Gccs.emplace_back(
"mingw32-gcc");
458 for (StringRef CandidateGcc : Gccs)
459 if (llvm::ErrorOr<std::string> GPPName = llvm::sys::findProgramByName(CandidateGcc))
464static llvm::ErrorOr<std::string>
466 const llvm::Triple &
T, std::string &SubdirName) {
468 Subdirs.emplace_back(LiteralTriple.str());
469 Subdirs.emplace_back(
T.str());
470 Subdirs.emplace_back(
T.getArchName());
471 Subdirs.back() +=
"-w64-mingw32";
472 Subdirs.emplace_back(
T.getArchName());
473 Subdirs.back() +=
"-w64-mingw32ucrt";
474 StringRef ClangRoot = llvm::sys::path::parent_path(
D.Dir);
475 StringRef Sep = llvm::sys::path::get_separator();
476 for (StringRef CandidateSubdir : Subdirs) {
477 if (llvm::sys::fs::is_directory(ClangRoot + Sep + CandidateSubdir)) {
478 SubdirName = std::string(CandidateSubdir);
479 return (ClangRoot + Sep + CandidateSubdir).str();
486 StringRef Sep = llvm::sys::path::get_separator();
487 if (!llvm::sys::fs::exists(Directory + Sep +
"include" + Sep +
"_mingw.h"))
489 if (!llvm::sys::fs::exists(Directory + Sep +
"lib" + Sep +
"libkernel32.a"))
496 :
ToolChain(
D, Triple, Args), CudaInstallation(
D, Triple, Args),
497 RocmInstallation(
D, Triple, Args) {
500 std::string InstallBase =
501 std::string(llvm::sys::path::parent_path(
getDriver().Dir));
511 Base = std::string(llvm::sys::path::parent_path(TargetSubdir.get()));
517 else if (llvm::ErrorOr<std::string> GPPName =
519 Base = std::string(llvm::sys::path::parent_path(
520 llvm::sys::path::parent_path(GPPName.get())));
524 Base += llvm::sys::path::get_separator();
525 findGccLibDir(LiteralTriple);
526 TripleDirName = SubdirName;
532 std::string CandidateSubdir = SubdirName +
"/sys-root/mingw";
534 SubdirName = CandidateSubdir;
537 (
Base + SubdirName + llvm::sys::path::get_separator() +
"lib").str());
541 (
Base + SubdirName + llvm::sys::path::get_separator() +
"mingw/lib").str());
552 Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
553 .equals_insensitive(
"lld");
565 return Compiler.get();
580 return NativeLLVMSupport;
585 Arg *ExceptionArg = Args.getLastArg(options::OPT_fsjlj_exceptions,
586 options::OPT_fseh_exceptions,
587 options::OPT_fdwarf_exceptions);
589 ExceptionArg->getOption().matches(options::OPT_fseh_exceptions))
590 return UnwindTableLevel::Asynchronous;
592 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||
593 getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)
594 return UnwindTableLevel::Asynchronous;
595 return UnwindTableLevel::None;
599 return getArch() == llvm::Triple::x86_64 ||
600 getArch() == llvm::Triple::aarch64;
609llvm::ExceptionHandling
611 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::aarch64 ||
612 getArch() == llvm::Triple::arm || getArch() == llvm::Triple::thumb)
613 return llvm::ExceptionHandling::WinEH;
614 return llvm::ExceptionHandling::DwarfCFI;
619 Res |= SanitizerKind::Address;
620 Res |= SanitizerKind::PointerCompare;
621 Res |= SanitizerKind::PointerSubtract;
622 Res |= SanitizerKind::Vptr;
627 ArgStringList &CC1Args)
const {
628 CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);
632 ArgStringList &CC1Args)
const {
633 RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);
637 CudaInstallation->print(OS);
638 RocmInstallation->print(OS);
688 ArgStringList &CC1Args)
const {
689 if (DriverArgs.hasArg(options::OPT_nostdinc))
692 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
694 llvm::sys::path::append(
P,
"include");
695 addSystemInclude(DriverArgs, CC1Args,
P.str());
698 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
701 addSystemInclude(DriverArgs, CC1Args,
702 Base + SubdirName + llvm::sys::path::get_separator() +
706 addSystemInclude(DriverArgs, CC1Args,
707 Base + SubdirName + llvm::sys::path::get_separator() +
"usr/include");
714 getDriver().SysRoot.size())
715 addSystemInclude(DriverArgs, CC1Args,
Base +
"include");
719 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
721 if (Arg *A = DriverArgs.getLastArg(options::OPT_mguard_EQ)) {
722 StringRef GuardArgs = A->getValue();
723 if (GuardArgs ==
"none") {
725 }
else if (GuardArgs ==
"cf") {
727 CC1Args.push_back(
"-cfguard");
728 }
else if (GuardArgs ==
"cf-nochecks") {
730 CC1Args.push_back(
"-cfguard-no-checks");
732 getDriver().Diag(diag::err_drv_unsupported_option_argument)
733 << A->getSpelling() << GuardArgs;
757 if (!DriverArgs.hasArgNoClaim(options::OPT_fsized_deallocation,
758 options::OPT_fno_sized_deallocation))
759 CC1Args.push_back(
"-fno-sized-deallocation");
761 CC1Args.push_back(
"-fno-use-init-array");
763 for (
auto Opt : {options::OPT_mthreads, options::OPT_mwindows,
764 options::OPT_mconsole, options::OPT_mdll}) {
765 if (Arg *A = DriverArgs.getLastArgNoClaim(Opt))
766 A->ignoreTargetSpecific();
771 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
772 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
773 options::OPT_nostdincxx))
776 StringRef Slash = llvm::sys::path::get_separator();
778 switch (GetCXXStdlibType(DriverArgs)) {
780 std::string TargetDir = (
Base +
"include" + Slash + getTripleString() +
781 Slash +
"c++" + Slash +
"v1")
783 if (getDriver().getVFS().exists(TargetDir))
784 addSystemInclude(DriverArgs, CC1Args, TargetDir);
785 addSystemInclude(DriverArgs, CC1Args,
786 Base + SubdirName + Slash +
"include" + Slash +
"c++" +
788 addSystemInclude(DriverArgs, CC1Args,
789 Base +
"include" + Slash +
"c++" + Slash +
"v1");
795 CppIncludeBases.emplace_back(
Base);
796 llvm::sys::path::append(CppIncludeBases[0], SubdirName,
"include",
"c++");
797 CppIncludeBases.emplace_back(
Base);
798 llvm::sys::path::append(CppIncludeBases[1], SubdirName,
"include",
"c++",
800 CppIncludeBases.emplace_back(
Base);
801 llvm::sys::path::append(CppIncludeBases[2],
"include",
"c++", Ver);
802 CppIncludeBases.emplace_back(GccLibDir);
803 llvm::sys::path::append(CppIncludeBases[3],
"include",
"c++");
804 CppIncludeBases.emplace_back(GccLibDir);
805 llvm::sys::path::append(CppIncludeBases[4],
"include",
806 "g++-v" + GccVer.Text);
807 CppIncludeBases.emplace_back(GccLibDir);
808 llvm::sys::path::append(CppIncludeBases[5],
"include",
809 "g++-v" + GccVer.MajorStr +
"." + GccVer.MinorStr);
810 CppIncludeBases.emplace_back(GccLibDir);
811 llvm::sys::path::append(CppIncludeBases[6],
"include",
812 "g++-v" + GccVer.MajorStr);
813 for (
auto &CppIncludeBase : CppIncludeBases) {
814 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);
815 CppIncludeBase += Slash;
816 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + TripleDirName);
817 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase +
"backward");
824 const ArgList &Args) {
827 std::string SubdirName;
828 if (
D.SysRoot.size())
831 std::string InstallBase = std::string(llvm::sys::path::parent_path(
D.Dir));
832 if (llvm::ErrorOr<std::string> TargetSubdir =
839 if (llvm::ErrorOr<std::string> GPPName =
findGcc(LiteralTriple, Triple))
847 const ArgList &Args) {
855 if (Triple.getArch() == llvm::Triple::x86) {
856 Archs.emplace_back(
"i386");
857 Archs.emplace_back(
"i586");
858 Archs.emplace_back(
"i686");
859 }
else if (Triple.getArch() == llvm::Triple::arm ||
860 Triple.getArch() == llvm::Triple::thumb) {
861 Archs.emplace_back(
"armv7");
863 for (
auto A : Archs) {
864 llvm::Triple TestTriple(Triple);
865 TestTriple.setArchName(A);
874 const ArgList &Args) {
875 if (Triple.getArch() == llvm::Triple::x86 ||
876 Triple.getArch() == llvm::Triple::arm ||
877 Triple.getArch() == llvm::Triple::thumb)
static llvm::Triple getLiteralTriple(const Driver &D, const llvm::Triple &T)
static bool looksLikeMinGWSysroot(const std::string &Directory)
static bool findGccVersion(StringRef LibDir, std::string &GccLibDir, std::string &Ver, toolchains::Generic_GCC::GCCVersion &Version)
static bool testTriple(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
static llvm::Triple adjustTriple(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
static llvm::ErrorOr< std::string > findGcc(const llvm::Triple &LiteralTriple, const llvm::Triple &T)
static llvm::ErrorOr< std::string > findClangRelativeSysroot(const Driver &D, const llvm::Triple &LiteralTriple, const llvm::Triple &T, std::string &SubdirName)
static bool isCrossCompiling(const llvm::Triple &T, bool RequireArchMatch)
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
@ OMPRT_Unknown
An unknown OpenMP runtime.
@ OMPRT_GOMP
The GNU OpenMP runtime.
The JSON file list parser is used to communicate input to InstallAPI.
std::error_code make_error_code(BuildPreambleError Error)
const FunctionProtoType * T
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
static constexpr ResponseFileSupport AtFileUTF8()