1//===-- MSVC.cpp - MSVC ToolChain Implementations -------------------------===//
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 "MSVC.h"
10#include "Darwin.h"
11#include "clang/Config/config.h"
12#include "clang/Driver/CommonArgs.h"
13#include "clang/Driver/Compilation.h"
14#include "clang/Driver/Driver.h"
15#include "clang/Driver/SanitizerArgs.h"
16#include "clang/Options/Options.h"
17#include "llvm/Option/Arg.h"
18#include "llvm/Option/ArgList.h"
19#include "llvm/Support/ConvertUTF.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/FileSystem.h"
22#include "llvm/Support/Path.h"
23#include "llvm/Support/Process.h"
24#include "llvm/Support/VirtualFileSystem.h"
25#include "llvm/TargetParser/Host.h"
26#include <cstdio>
27
28#ifdef _WIN32
29 #define WIN32_LEAN_AND_MEAN
30 #define NOGDI
31 #ifndef NOMINMAX
32 #define NOMINMAX
33 #endif
34 #include <windows.h>
35#endif
36
37using namespace clang::driver;
38using namespace clang::driver::toolchains;
39using namespace clang::driver::tools;
40using namespace clang;
41using namespace llvm::opt;
42
43static bool canExecute(llvm::vfs::FileSystem &VFS, StringRef Path) {
44 auto Status = VFS.status(Path);
45 if (!Status)
46 return false;
47 return (Status->getPermissions() & llvm::sys::fs::perms::all_exe) != 0;
48}
49
50// Try to find Exe from a Visual Studio distribution. This first tries to find
51// an installed copy of Visual Studio and, failing that, looks in the PATH,
52// making sure that whatever executable that's found is not a same-named exe
53// from clang itself to prevent clang from falling back to itself.
54static std::string FindVisualStudioExecutable(const ToolChain &TC,
55 const char *Exe) {
56 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
57 SmallString<128> FilePath(
58 MSVC.getSubDirectoryPath(Type: llvm::SubDirectoryType::Bin));
59 llvm::sys::path::append(path&: FilePath, a: Exe);
60 return std::string(canExecute(VFS&: TC.getVFS(), Path: FilePath) ? FilePath.str() : Exe);
61}
62
63void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
64 const InputInfo &Output,
65 const InputInfoList &Inputs,
66 const ArgList &Args,
67 const char *LinkingOutput) const {
68 ArgStringList CmdArgs;
69
70 auto &TC = static_cast<const toolchains::MSVCToolChain &>(getToolChain());
71
72 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
73 if (Output.isFilename())
74 CmdArgs.push_back(
75 Elt: Args.MakeArgString(Str: std::string("-out:") + Output.getFilename()));
76
77 if (Args.hasArg(Ids: options::OPT_marm64x))
78 CmdArgs.push_back(Elt: "-machine:arm64x");
79 else if (TC.getTriple().isWindowsArm64EC())
80 CmdArgs.push_back(Elt: "-machine:arm64ec");
81
82 if (const Arg *A = Args.getLastArg(Ids: options::OPT_fveclib)) {
83 StringRef V = A->getValue();
84 if (V == "ArmPL")
85 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--dependent-lib=amath"));
86 }
87
88 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nostartfiles) &&
89 !C.getDriver().IsCLMode() && !C.getDriver().IsFlangMode()) {
90 CmdArgs.push_back(Elt: "-defaultlib:libcmt");
91 CmdArgs.push_back(Elt: "-defaultlib:oldnames");
92 }
93
94 // If the VC environment hasn't been configured (perhaps because the user
95 // did not run vcvarsall), try to build a consistent link environment. If
96 // the environment variable is set however, assume the user knows what
97 // they're doing. If the user passes /vctoolsdir or /winsdkdir, trust that
98 // over env vars.
99 if (const Arg *A = Args.getLastArg(Ids: options::OPT__SLASH_diasdkdir,
100 Ids: options::OPT__SLASH_winsysroot)) {
101 // cl.exe doesn't find the DIA SDK automatically, so this too requires
102 // explicit flags and doesn't automatically look in "DIA SDK" relative
103 // to the path we found for VCToolChainPath.
104 llvm::SmallString<128> DIAPath(A->getValue());
105 if (A->getOption().getID() == options::OPT__SLASH_winsysroot)
106 llvm::sys::path::append(path&: DIAPath, a: "DIA SDK");
107
108 // The DIA SDK always uses the legacy vc arch, even in new MSVC versions.
109 llvm::sys::path::append(path&: DIAPath, a: "lib",
110 b: llvm::archToLegacyVCArch(Arch: TC.getArch()));
111 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine("-libpath:") + DIAPath));
112 }
113 if (!llvm::sys::Process::GetEnv(name: "LIB") ||
114 Args.hasArg(Ids: options::OPT__SLASH_vctoolsdir,
115 Ids: options::OPT__SLASH_vctoolsversion,
116 Ids: options::OPT__SLASH_winsysroot)) {
117 CmdArgs.push_back(Elt: Args.MakeArgString(
118 Str: Twine("-libpath:") +
119 TC.getSubDirectoryPath(Type: llvm::SubDirectoryType::Lib)));
120 CmdArgs.push_back(Elt: Args.MakeArgString(
121 Str: Twine("-libpath:") +
122 TC.getSubDirectoryPath(Type: llvm::SubDirectoryType::Lib, SubdirParent: "atlmfc")));
123 }
124 if (!llvm::sys::Process::GetEnv(name: "LIB") ||
125 Args.hasArg(Ids: options::OPT__SLASH_winsdkdir,
126 Ids: options::OPT__SLASH_winsdkversion,
127 Ids: options::OPT__SLASH_winsysroot)) {
128 if (TC.useUniversalCRT()) {
129 std::string UniversalCRTLibPath;
130 if (TC.getUniversalCRTLibraryPath(Args, path&: UniversalCRTLibPath))
131 CmdArgs.push_back(
132 Elt: Args.MakeArgString(Str: Twine("-libpath:") + UniversalCRTLibPath));
133 }
134 std::string WindowsSdkLibPath;
135 if (TC.getWindowsSDKLibraryPath(Args, path&: WindowsSdkLibPath))
136 CmdArgs.push_back(
137 Elt: Args.MakeArgString(Str: std::string("-libpath:") + WindowsSdkLibPath));
138 }
139
140 if (!C.getDriver().IsCLMode() && Args.hasArg(Ids: options::OPT_L))
141 for (const auto &LibPath : Args.getAllArgValues(Id: options::OPT_L))
142 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-libpath:" + LibPath));
143
144 if (C.getDriver().IsFlangMode() &&
145 !Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
146 TC.addFortranRuntimeLibraryPath(Args, CmdArgs);
147 TC.addFortranRuntimeLibs(Args, CmdArgs);
148
149 // Inform the MSVC linker that we're generating a console application, i.e.
150 // one with `main` as the "user-defined" entry point. The `main` function is
151 // defined in flang's runtime libraries.
152 CmdArgs.push_back(Elt: "/subsystem:console");
153 }
154
155 // Add the compiler-rt library directories to libpath if they exist to help
156 // the linker find the various sanitizer, builtin, and profiling runtimes.
157 for (const auto &LibPath : TC.getLibraryPaths()) {
158 if (TC.getVFS().exists(Path: LibPath))
159 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-libpath:" + LibPath));
160 }
161 auto CRTPath = TC.getCompilerRTPath();
162 if (TC.getVFS().exists(Path: CRTPath))
163 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-libpath:" + CRTPath));
164
165 CmdArgs.push_back(Elt: "-nologo");
166
167 if (Args.hasArg(Ids: options::OPT_g_Group, Ids: options::OPT__SLASH_Z7))
168 CmdArgs.push_back(Elt: "-debug");
169
170 // If we specify /hotpatch, let the linker add padding in front of each
171 // function, like MSVC does.
172 if (Args.hasArg(Ids: options::OPT_fms_hotpatch, Ids: options::OPT__SLASH_hotpatch))
173 CmdArgs.push_back(Elt: "-functionpadmin");
174
175 // Pass on /Brepro if it was passed to the compiler.
176 // Note that /Brepro maps to -mno-incremental-linker-compatible.
177 bool DefaultIncrementalLinkerCompatible =
178 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
179 if (!Args.hasFlag(Pos: options::OPT_mincremental_linker_compatible,
180 Neg: options::OPT_mno_incremental_linker_compatible,
181 Default: DefaultIncrementalLinkerCompatible))
182 CmdArgs.push_back(Elt: "-Brepro");
183
184 bool DLL = Args.hasArg(Ids: options::OPT__SLASH_LD, Ids: options::OPT__SLASH_LDd,
185 Ids: options::OPT_shared);
186 if (DLL) {
187 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-dll"));
188
189 SmallString<128> ImplibName(Output.getFilename());
190 llvm::sys::path::replace_extension(path&: ImplibName, extension: "lib");
191 CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::string("-implib:") + ImplibName));
192 }
193
194 if (TC.getSanitizerArgs(JobArgs: Args).needsFuzzer()) {
195 if (!Args.hasArg(Ids: options::OPT_shared))
196 CmdArgs.push_back(
197 Elt: Args.MakeArgString(Str: std::string("-wholearchive:") +
198 TC.getCompilerRTArgString(Args, Component: "fuzzer")));
199 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-debug"));
200 // Prevent the linker from padding sections we use for instrumentation
201 // arrays.
202 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-incremental:no"));
203 }
204
205 if (TC.getSanitizerArgs(JobArgs: Args).needsAsanRt()) {
206 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-debug"));
207 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-incremental:no"));
208 CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: "asan_dynamic"));
209 auto defines = Args.getAllArgValues(Id: options::OPT_D);
210 if (Args.hasArg(Ids: options::OPT__SLASH_MD, Ids: options::OPT__SLASH_MDd) ||
211 llvm::is_contained(Range&: defines, Element: "_DLL")) {
212 // Make sure the dynamic runtime thunk is not optimized out at link time
213 // to ensure proper SEH handling.
214 CmdArgs.push_back(Elt: Args.MakeArgString(
215 Str: TC.getArch() == llvm::Triple::x86
216 ? "-include:___asan_seh_interceptor"
217 : "-include:__asan_seh_interceptor"));
218 // Make sure the linker consider all object files from the dynamic runtime
219 // thunk.
220 CmdArgs.push_back(Elt: Args.MakeArgString(
221 Str: std::string("-wholearchive:") +
222 TC.getCompilerRT(Args, Component: "asan_dynamic_runtime_thunk")));
223 } else {
224 // Make sure the linker consider all object files from the static runtime
225 // thunk.
226 CmdArgs.push_back(Elt: Args.MakeArgString(
227 Str: std::string("-wholearchive:") +
228 TC.getCompilerRT(Args, Component: "asan_static_runtime_thunk")));
229 }
230 }
231
232 if (C.getDriver().isUsingLTO()) {
233 if (Arg *A = tools::getLastProfileSampleUseArg(Args))
234 CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::string("-lto-sample-profile:") +
235 A->getValue()));
236 }
237 Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT__SLASH_link);
238
239 // Control Flow Guard checks
240 for (const Arg *A : Args.filtered(Ids: options::OPT__SLASH_guard)) {
241 StringRef GuardArgs = A->getValue();
242 if (GuardArgs.equals_insensitive(RHS: "cf") ||
243 GuardArgs.equals_insensitive(RHS: "cf,nochecks")) {
244 // MSVC doesn't yet support the "nochecks" modifier.
245 CmdArgs.push_back(Elt: "-guard:cf");
246 } else if (GuardArgs.equals_insensitive(RHS: "cf-")) {
247 CmdArgs.push_back(Elt: "-guard:cf-");
248 } else if (GuardArgs.equals_insensitive(RHS: "ehcont")) {
249 CmdArgs.push_back(Elt: "-guard:ehcont");
250 } else if (GuardArgs.equals_insensitive(RHS: "ehcont-")) {
251 CmdArgs.push_back(Elt: "-guard:ehcont-");
252 }
253 }
254
255 if (Args.hasFlag(Pos: options::OPT_fopenmp, PosAlias: options::OPT_fopenmp_EQ,
256 Neg: options::OPT_fno_openmp, Default: false)) {
257 CmdArgs.push_back(Elt: "-nodefaultlib:vcomp.lib");
258 CmdArgs.push_back(Elt: "-nodefaultlib:vcompd.lib");
259 CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::string("-libpath:") +
260 TC.getDriver().Dir + "/../lib"));
261 switch (TC.getDriver().getOpenMPRuntime(Args)) {
262 case Driver::OMPRT_OMP:
263 CmdArgs.push_back(Elt: "-defaultlib:libomp.lib");
264 break;
265 case Driver::OMPRT_IOMP5:
266 CmdArgs.push_back(Elt: "-defaultlib:libiomp5md.lib");
267 break;
268 case Driver::OMPRT_GOMP:
269 break;
270 case Driver::OMPRT_Unknown:
271 // Already diagnosed.
272 break;
273 }
274 }
275
276 // Add compiler-rt lib in case if it was explicitly
277 // specified as an argument for --rtlib option.
278 if (!Args.hasArg(Ids: options::OPT_nostdlib)) {
279 AddRunTimeLibs(TC, D: TC.getDriver(), CmdArgs, Args);
280 }
281
282 StringRef Linker = Args.getLastArgValue(Id: options::OPT_fuse_ld_EQ,
283 Default: TC.getDriver().getPreferredLinker());
284 if (Linker.empty())
285 Linker = "link";
286 // We need to translate 'lld' into 'lld-link'.
287 else if (Linker.equals_insensitive(RHS: "lld"))
288 Linker = "lld-link";
289
290 if (Linker == "lld-link") {
291 for (Arg *A : Args.filtered(Ids: options::OPT_vfsoverlay))
292 CmdArgs.push_back(
293 Elt: Args.MakeArgString(Str: std::string("/vfsoverlay:") + A->getValue()));
294
295 if (C.getDriver().isUsingLTO() &&
296 Args.hasFlag(Pos: options::OPT_gsplit_dwarf, Neg: options::OPT_gno_split_dwarf,
297 Default: false))
298 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine("/dwodir:") +
299 Output.getFilename() + "_dwo"));
300 }
301
302 // Add filenames, libraries, and other linker inputs.
303 for (const auto &Input : Inputs) {
304 if (Input.isFilename()) {
305 CmdArgs.push_back(Elt: Input.getFilename());
306 continue;
307 }
308
309 const Arg &A = Input.getInputArg();
310
311 // Render -l options differently for the MSVC linker.
312 if (A.getOption().matches(ID: options::OPT_l)) {
313 StringRef Lib = A.getValue();
314 const char *LinkLibArg;
315 if (Lib.ends_with(Suffix: ".lib"))
316 LinkLibArg = Args.MakeArgString(Str: Lib);
317 else
318 LinkLibArg = Args.MakeArgString(Str: Lib + ".lib");
319 CmdArgs.push_back(Elt: LinkLibArg);
320 continue;
321 }
322
323 // Otherwise, this is some other kind of linker input option like -Wl, -z,
324 // or -L. Render it, even if MSVC doesn't understand it.
325 A.renderAsInput(Args, Output&: CmdArgs);
326 }
327
328 TC.addOffloadRTLibs(ActiveKinds: C.getActiveOffloadKinds(), Args, CmdArgs);
329
330 TC.addProfileRTLibs(Args, CmdArgs);
331
332 std::vector<const char *> Environment;
333
334 // We need to special case some linker paths. In the case of the regular msvc
335 // linker, we need to use a special search algorithm.
336 llvm::SmallString<128> linkPath;
337 if (Linker.equals_insensitive(RHS: "link")) {
338 // If we're using the MSVC linker, it's not sufficient to just use link
339 // from the program PATH, because other environments like GnuWin32 install
340 // their own link.exe which may come first.
341 linkPath = FindVisualStudioExecutable(TC, Exe: "link.exe");
342
343 if (!TC.FoundMSVCInstall() && !canExecute(VFS&: TC.getVFS(), Path: linkPath)) {
344 llvm::SmallString<128> ClPath;
345 ClPath = TC.GetProgramPath(Name: "cl.exe");
346 if (canExecute(VFS&: TC.getVFS(), Path: ClPath)) {
347 linkPath = llvm::sys::path::parent_path(path: ClPath);
348 llvm::sys::path::append(path&: linkPath, a: "link.exe");
349 if (!canExecute(VFS&: TC.getVFS(), Path: linkPath))
350 C.getDriver().Diag(DiagID: clang::diag::warn_drv_msvc_not_found);
351 } else {
352 C.getDriver().Diag(DiagID: clang::diag::warn_drv_msvc_not_found);
353 }
354 }
355
356 // Clang handles passing the proper asan libs to the linker, which goes
357 // against link.exe's /INFERASANLIBS which automatically finds asan libs.
358 if (TC.getSanitizerArgs(JobArgs: Args).needsAsanRt())
359 CmdArgs.push_back(Elt: "/INFERASANLIBS:NO");
360
361#ifdef _WIN32
362 // When cross-compiling with VS2017 or newer, link.exe expects to have
363 // its containing bin directory at the top of PATH, followed by the
364 // native target bin directory.
365 // e.g. when compiling for x86 on an x64 host, PATH should start with:
366 // /bin/Hostx64/x86;/bin/Hostx64/x64
367 // This doesn't attempt to handle llvm::ToolsetLayout::DevDivInternal.
368 if (TC.getIsVS2017OrNewer() &&
369 llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {
370 auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();
371
372 auto EnvBlockWide =
373 std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(
374 GetEnvironmentStringsW(), FreeEnvironmentStringsW);
375 if (!EnvBlockWide)
376 goto SkipSettingEnvironment;
377
378 size_t EnvCount = 0;
379 size_t EnvBlockLen = 0;
380 while (EnvBlockWide[EnvBlockLen] != L'\0') {
381 ++EnvCount;
382 EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +
383 1 /*string null-terminator*/;
384 }
385 ++EnvBlockLen; // add the block null-terminator
386
387 std::string EnvBlock;
388 if (!llvm::convertUTF16ToUTF8String(
389 llvm::ArrayRef<char>(reinterpret_cast<char *>(EnvBlockWide.get()),
390 EnvBlockLen * sizeof(EnvBlockWide[0])),
391 EnvBlock))
392 goto SkipSettingEnvironment;
393
394 Environment.reserve(EnvCount);
395
396 // Now loop over each string in the block and copy them into the
397 // environment vector, adjusting the PATH variable as needed when we
398 // find it.
399 for (const char *Cursor = EnvBlock.data(); *Cursor != '\0';) {
400 llvm::StringRef EnvVar(Cursor);
401 if (EnvVar.starts_with_insensitive("path=")) {
402 constexpr size_t PrefixLen = 5; // strlen("path=")
403 Environment.push_back(Args.MakeArgString(
404 EnvVar.substr(0, PrefixLen) +
405 TC.getSubDirectoryPath(llvm::SubDirectoryType::Bin) +
406 llvm::Twine(llvm::sys::EnvPathSeparator) +
407 TC.getSubDirectoryPath(llvm::SubDirectoryType::Bin, HostArch) +
408 (EnvVar.size() > PrefixLen
409 ? llvm::Twine(llvm::sys::EnvPathSeparator) +
410 EnvVar.substr(PrefixLen)
411 : "")));
412 } else {
413 Environment.push_back(Args.MakeArgString(EnvVar));
414 }
415 Cursor += EnvVar.size() + 1 /*null-terminator*/;
416 }
417 }
418 SkipSettingEnvironment:;
419#endif
420 } else {
421 linkPath = TC.GetProgramPath(Name: Linker.str().c_str());
422 }
423
424 auto LinkCmd = std::make_unique<Command>(
425 args: JA, args: *this, args: ResponseFileSupport::AtFileUTF16(),
426 args: Args.MakeArgString(Str: linkPath), args&: CmdArgs, args: Inputs, args: Output);
427 if (!Environment.empty())
428 LinkCmd->setEnvironment(Environment);
429 C.addCommand(C: std::move(LinkCmd));
430}
431
432MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
433 const ArgList &Args)
434 : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
435 RocmInstallation(D, Triple, Args), SYCLInstallation(D, Triple, Args) {
436 getProgramPaths().push_back(Elt: getDriver().Dir);
437
438 std::optional<llvm::StringRef> VCToolsDir, VCToolsVersion;
439 if (Arg *A = Args.getLastArg(Ids: options::OPT__SLASH_vctoolsdir))
440 VCToolsDir = A->getValue();
441 if (Arg *A = Args.getLastArg(Ids: options::OPT__SLASH_vctoolsversion))
442 VCToolsVersion = A->getValue();
443 if (Arg *A = Args.getLastArg(Ids: options::OPT__SLASH_winsdkdir))
444 WinSdkDir = A->getValue();
445 if (Arg *A = Args.getLastArg(Ids: options::OPT__SLASH_winsdkversion))
446 WinSdkVersion = A->getValue();
447 if (Arg *A = Args.getLastArg(Ids: options::OPT__SLASH_winsysroot))
448 WinSysRoot = A->getValue();
449
450 // Check the command line first, that's the user explicitly telling us what to
451 // use. Check the environment next, in case we're being invoked from a VS
452 // command prompt. Failing that, just try to find the newest Visual Studio
453 // version we can and use its default VC toolchain.
454 llvm::findVCToolChainViaCommandLine(VFS&: getVFS(), VCToolsDir, VCToolsVersion,
455 WinSysRoot, Path&: VCToolChainPath, VSLayout) ||
456 llvm::findVCToolChainViaEnvironment(VFS&: getVFS(), Path&: VCToolChainPath,
457 VSLayout) ||
458 llvm::findVCToolChainViaSetupConfig(VFS&: getVFS(), VCToolsVersion,
459 Path&: VCToolChainPath, VSLayout) ||
460 llvm::findVCToolChainViaRegistry(Path&: VCToolChainPath, VSLayout);
461}
462
463Tool *MSVCToolChain::buildLinker() const {
464 return new tools::visualstudio::Linker(*this);
465}
466
467Tool *MSVCToolChain::buildAssembler() const {
468 if (getTriple().isOSBinFormatMachO())
469 return new tools::darwin::Assembler(*this);
470 getDriver().Diag(DiagID: clang::diag::err_no_external_assembler);
471 return nullptr;
472}
473
474ToolChain::UnwindTableLevel
475MSVCToolChain::getDefaultUnwindTableLevel(const ArgList &Args) const {
476 // Don't emit unwind tables by default for MachO targets.
477 if (getTriple().isOSBinFormatMachO())
478 return UnwindTableLevel::None;
479
480 // All non-x86_32 Windows targets require unwind tables. However, LLVM
481 // doesn't know how to generate them for all targets, so only enable
482 // the ones that are actually implemented.
483 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||
484 getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)
485 return UnwindTableLevel::Asynchronous;
486
487 return UnwindTableLevel::None;
488}
489
490bool MSVCToolChain::isPICDefault() const {
491 return getArch() == llvm::Triple::x86_64 ||
492 getArch() == llvm::Triple::aarch64;
493}
494
495bool MSVCToolChain::isPIEDefault(const llvm::opt::ArgList &Args) const {
496 return false;
497}
498
499bool MSVCToolChain::isPICDefaultForced() const {
500 return getArch() == llvm::Triple::x86_64 ||
501 getArch() == llvm::Triple::aarch64;
502}
503
504void MSVCToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
505 ArgStringList &CC1Args) const {
506 CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);
507}
508
509void MSVCToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs,
510 ArgStringList &CC1Args) const {
511 RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);
512}
513
514void MSVCToolChain::addSYCLIncludeArgs(const ArgList &DriverArgs,
515 ArgStringList &CC1Args) const {
516 SYCLInstallation->addSYCLIncludeArgs(DriverArgs, CC1Args);
517}
518
519void MSVCToolChain::addOffloadRTLibs(unsigned ActiveKinds, const ArgList &Args,
520 ArgStringList &CmdArgs) const {
521 if (!Args.hasFlag(Pos: options::OPT_offloadlib, Neg: options::OPT_no_offloadlib,
522 Default: true) ||
523 Args.hasArg(Ids: options::OPT_no_hip_rt) || Args.hasArg(Ids: options::OPT_r))
524 return;
525
526 if (ActiveKinds & Action::OFK_HIP) {
527 CmdArgs.append(IL: {Args.MakeArgString(Str: StringRef("-libpath:") +
528 RocmInstallation->getLibPath()),
529 "amdhip64.lib"});
530 }
531}
532
533void MSVCToolChain::printVerboseInfo(raw_ostream &OS) const {
534 CudaInstallation->print(OS);
535 RocmInstallation->print(OS);
536}
537
538std::string
539MSVCToolChain::getSubDirectoryPath(llvm::SubDirectoryType Type,
540 llvm::StringRef SubdirParent) const {
541 return llvm::getSubDirectoryPath(Type, VSLayout, VCToolChainPath, TargetArch: getArch(),
542 SubdirParent);
543}
544
545std::string
546MSVCToolChain::getSubDirectoryPath(llvm::SubDirectoryType Type,
547 llvm::Triple::ArchType TargetArch) const {
548 return llvm::getSubDirectoryPath(Type, VSLayout, VCToolChainPath, TargetArch,
549 SubdirParent: "");
550}
551
552// Find the most recent version of Universal CRT or Windows 10 SDK.
553// vcvarsqueryregistry.bat from Visual Studio 2015 sorts entries in the include
554// directory by name and uses the last one of the list.
555// So we compare entry names lexicographically to find the greatest one.
556// Gets the library path required to link against the Windows SDK.
557bool MSVCToolChain::getWindowsSDKLibraryPath(const ArgList &Args,
558 std::string &path) const {
559 std::string sdkPath;
560 int sdkMajor = 0;
561 std::string windowsSDKIncludeVersion;
562 std::string windowsSDKLibVersion;
563
564 path.clear();
565 if (!llvm::getWindowsSDKDir(VFS&: getVFS(), WinSdkDir, WinSdkVersion, WinSysRoot,
566 Path&: sdkPath, Major&: sdkMajor, WindowsSDKIncludeVersion&: windowsSDKIncludeVersion,
567 WindowsSDKLibVersion&: windowsSDKLibVersion))
568 return false;
569
570 llvm::SmallString<128> libPath(sdkPath);
571 llvm::sys::path::append(path&: libPath, a: "Lib");
572 if (sdkMajor >= 10)
573 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
574 WinSdkVersion.has_value())
575 windowsSDKLibVersion = *WinSdkVersion;
576 if (sdkMajor >= 8)
577 llvm::sys::path::append(path&: libPath, a: windowsSDKLibVersion, b: "um");
578 return llvm::appendArchToWindowsSDKLibPath(SDKMajor: sdkMajor, LibPath: libPath, Arch: getArch(),
579 path);
580}
581
582bool MSVCToolChain::useUniversalCRT() const {
583 return llvm::useUniversalCRT(VSLayout, VCToolChainPath, TargetArch: getArch(), VFS&: getVFS());
584}
585
586bool MSVCToolChain::getUniversalCRTLibraryPath(const ArgList &Args,
587 std::string &Path) const {
588 std::string UniversalCRTSdkPath;
589 std::string UCRTVersion;
590
591 Path.clear();
592 if (!llvm::getUniversalCRTSdkDir(VFS&: getVFS(), WinSdkDir, WinSdkVersion,
593 WinSysRoot, Path&: UniversalCRTSdkPath,
594 UCRTVersion))
595 return false;
596
597 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
598 WinSdkVersion.has_value())
599 UCRTVersion = *WinSdkVersion;
600
601 StringRef ArchName = llvm::archToWindowsSDKArch(Arch: getArch());
602 if (ArchName.empty())
603 return false;
604
605 llvm::SmallString<128> LibPath(UniversalCRTSdkPath);
606 llvm::sys::path::append(path&: LibPath, a: "Lib", b: UCRTVersion, c: "ucrt", d: ArchName);
607
608 Path = std::string(LibPath);
609 return true;
610}
611
612static VersionTuple getMSVCVersionFromExe(const std::string &BinDir) {
613 VersionTuple Version;
614#ifdef _WIN32
615 SmallString<128> ClExe(BinDir);
616 llvm::sys::path::append(ClExe, "cl.exe");
617
618 std::wstring ClExeWide;
619 if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
620 return Version;
621
622 const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
623 nullptr);
624 if (VersionSize == 0)
625 return Version;
626
627 SmallVector<uint8_t, 4 * 1024> VersionBlock(VersionSize);
628 if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
629 VersionBlock.data()))
630 return Version;
631
632 VS_FIXEDFILEINFO *FileInfo = nullptr;
633 UINT FileInfoSize = 0;
634 if (!::VerQueryValueW(VersionBlock.data(), L"\\",
635 reinterpret_cast<LPVOID *>(&FileInfo), &FileInfoSize) ||
636 FileInfoSize < sizeof(*FileInfo))
637 return Version;
638
639 const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
640 const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
641 const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
642
643 Version = VersionTuple(Major, Minor, Micro);
644#endif
645 return Version;
646}
647
648void MSVCToolChain::AddSystemIncludeWithSubfolder(
649 const ArgList &DriverArgs, ArgStringList &CC1Args,
650 const std::string &folder, const Twine &subfolder1, const Twine &subfolder2,
651 const Twine &subfolder3) const {
652 llvm::SmallString<128> path(folder);
653 llvm::sys::path::append(path, a: subfolder1, b: subfolder2, c: subfolder3);
654 addSystemInclude(DriverArgs, CC1Args, Path: path);
655}
656
657void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
658 ArgStringList &CC1Args) const {
659 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc))
660 return;
661
662 if (!DriverArgs.hasArg(Ids: options::OPT_nobuiltininc)) {
663 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: getDriver().ResourceDir,
664 subfolder1: "include");
665 }
666
667 // Add %INCLUDE%-like directories from the -imsvc flag.
668 for (const auto &Path : DriverArgs.getAllArgValues(Id: options::OPT__SLASH_imsvc))
669 addSystemInclude(DriverArgs, CC1Args, Path);
670
671 auto AddSystemIncludesFromEnv = [&](StringRef Var) -> bool {
672 if (auto Val = llvm::sys::Process::GetEnv(name: Var)) {
673 SmallVector<StringRef, 8> Dirs;
674 StringRef(*Val).split(A&: Dirs, Separator: ";", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
675 if (!Dirs.empty()) {
676 addSystemIncludes(DriverArgs, CC1Args, Paths: Dirs);
677 return true;
678 }
679 }
680 return false;
681 };
682
683 // Add %INCLUDE%-like dirs via /external:env: flags.
684 for (const auto &Var :
685 DriverArgs.getAllArgValues(Id: options::OPT__SLASH_external_env)) {
686 AddSystemIncludesFromEnv(Var);
687 }
688
689 // Add DIA SDK include if requested.
690 if (const Arg *A = DriverArgs.getLastArg(Ids: options::OPT__SLASH_diasdkdir,
691 Ids: options::OPT__SLASH_winsysroot)) {
692 // cl.exe doesn't find the DIA SDK automatically, so this too requires
693 // explicit flags and doesn't automatically look in "DIA SDK" relative
694 // to the path we found for VCToolChainPath.
695 llvm::SmallString<128> DIASDKPath(A->getValue());
696 if (A->getOption().getID() == options::OPT__SLASH_winsysroot)
697 llvm::sys::path::append(path&: DIASDKPath, a: "DIA SDK");
698 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: std::string(DIASDKPath),
699 subfolder1: "include");
700 }
701
702 if (DriverArgs.hasArg(Ids: options::OPT_nostdlibinc))
703 return;
704
705 // Honor %INCLUDE% and %EXTERNAL_INCLUDE%. It should have essential search
706 // paths set by vcvarsall.bat. Skip if the user expressly set any of the
707 // Windows SDK or VC Tools options.
708 if (!DriverArgs.hasArg(
709 Ids: options::OPT__SLASH_vctoolsdir, Ids: options::OPT__SLASH_vctoolsversion,
710 Ids: options::OPT__SLASH_winsysroot, Ids: options::OPT__SLASH_winsdkdir,
711 Ids: options::OPT__SLASH_winsdkversion)) {
712 bool Found = AddSystemIncludesFromEnv("INCLUDE");
713 Found |= AddSystemIncludesFromEnv("EXTERNAL_INCLUDE");
714 if (Found)
715 return;
716 }
717
718 // When built with access to the proper Windows APIs, try to actually find
719 // the correct include paths first.
720 if (!VCToolChainPath.empty()) {
721 addSystemInclude(DriverArgs, CC1Args,
722 Path: getSubDirectoryPath(Type: llvm::SubDirectoryType::Include));
723 addSystemInclude(
724 DriverArgs, CC1Args,
725 Path: getSubDirectoryPath(Type: llvm::SubDirectoryType::Include, SubdirParent: "atlmfc"));
726
727 if (useUniversalCRT()) {
728 std::string UniversalCRTSdkPath;
729 std::string UCRTVersion;
730 if (llvm::getUniversalCRTSdkDir(VFS&: getVFS(), WinSdkDir, WinSdkVersion,
731 WinSysRoot, Path&: UniversalCRTSdkPath,
732 UCRTVersion)) {
733 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
734 WinSdkVersion.has_value())
735 UCRTVersion = *WinSdkVersion;
736 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: UniversalCRTSdkPath,
737 subfolder1: "Include", subfolder2: UCRTVersion, subfolder3: "ucrt");
738 }
739 }
740
741 std::string WindowsSDKDir;
742 int major = 0;
743 std::string windowsSDKIncludeVersion;
744 std::string windowsSDKLibVersion;
745 if (llvm::getWindowsSDKDir(VFS&: getVFS(), WinSdkDir, WinSdkVersion, WinSysRoot,
746 Path&: WindowsSDKDir, Major&: major, WindowsSDKIncludeVersion&: windowsSDKIncludeVersion,
747 WindowsSDKLibVersion&: windowsSDKLibVersion)) {
748 if (major >= 10)
749 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
750 WinSdkVersion.has_value())
751 windowsSDKIncludeVersion = windowsSDKLibVersion = *WinSdkVersion;
752 if (major >= 8) {
753 // Note: windowsSDKIncludeVersion is empty for SDKs prior to v10.
754 // Anyway, llvm::sys::path::append is able to manage it.
755 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: WindowsSDKDir,
756 subfolder1: "Include", subfolder2: windowsSDKIncludeVersion,
757 subfolder3: "shared");
758 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: WindowsSDKDir,
759 subfolder1: "Include", subfolder2: windowsSDKIncludeVersion,
760 subfolder3: "um");
761 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: WindowsSDKDir,
762 subfolder1: "Include", subfolder2: windowsSDKIncludeVersion,
763 subfolder3: "winrt");
764 if (major >= 10) {
765 llvm::VersionTuple Tuple;
766 if (!Tuple.tryParse(string: windowsSDKIncludeVersion) &&
767 Tuple.getSubminor().value_or(u: 0) >= 17134) {
768 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: WindowsSDKDir,
769 subfolder1: "Include", subfolder2: windowsSDKIncludeVersion,
770 subfolder3: "cppwinrt");
771 }
772 }
773 } else {
774 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, folder: WindowsSDKDir,
775 subfolder1: "Include");
776 }
777 }
778
779 return;
780 }
781
782#if defined(_WIN32)
783 // As a fallback, select default install paths.
784 // FIXME: Don't guess drives and paths like this on Windows.
785 const StringRef Paths[] = {
786 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
787 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
788 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
789 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
790 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
791 };
792 addSystemIncludes(DriverArgs, CC1Args, Paths);
793#endif
794}
795
796void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
797 ArgStringList &CC1Args) const {
798 // FIXME: There should probably be logic here to find libc++ on Windows.
799}
800
801VersionTuple MSVCToolChain::computeMSVCVersion(const Driver *D,
802 const ArgList &Args) const {
803 bool IsWindowsMSVC = getTriple().isWindowsMSVCEnvironment();
804 VersionTuple MSVT = ToolChain::computeMSVCVersion(D, Args);
805 if (MSVT.empty())
806 MSVT = getTriple().getEnvironmentVersion();
807 if (MSVT.empty() && IsWindowsMSVC)
808 MSVT =
809 getMSVCVersionFromExe(BinDir: getSubDirectoryPath(Type: llvm::SubDirectoryType::Bin));
810 if (MSVT.empty() &&
811 Args.hasFlag(Pos: options::OPT_fms_extensions, Neg: options::OPT_fno_ms_extensions,
812 Default: IsWindowsMSVC)) {
813 // -fms-compatibility-version=19.33 is default, aka 2022, 17.3
814 // NOTE: when changing this value, also update
815 // clang/docs/CommandGuide/clang.rst and clang/docs/UsersManual.rst
816 // accordingly.
817 MSVT = VersionTuple(19, 33);
818 }
819 return MSVT;
820}
821
822std::string
823MSVCToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
824 types::ID InputType) const {
825 // The MSVC version doesn't care about the architecture, even though it
826 // may look at the triple internally.
827 VersionTuple MSVT = computeMSVCVersion(/*D=*/nullptr, Args);
828 MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().value_or(u: 0),
829 MSVT.getSubminor().value_or(u: 0));
830
831 // For the rest of the triple, however, a computed architecture name may
832 // be needed.
833 llvm::Triple Triple(ToolChain::ComputeEffectiveClangTriple(Args, InputType));
834 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
835 StringRef ObjFmt = Triple.getEnvironmentName().split(Separator: '-').second;
836 if (ObjFmt.empty())
837 Triple.setEnvironmentName((Twine("msvc") + MSVT.getAsString()).str());
838 else
839 Triple.setEnvironmentName(
840 (Twine("msvc") + MSVT.getAsString() + Twine('-') + ObjFmt).str());
841 }
842 return Triple.getTriple();
843}
844
845SanitizerMask MSVCToolChain::getSupportedSanitizers() const {
846 SanitizerMask Res = ToolChain::getSupportedSanitizers();
847 Res |= SanitizerKind::Address;
848 Res |= SanitizerKind::PointerCompare;
849 Res |= SanitizerKind::PointerSubtract;
850 Res |= SanitizerKind::Fuzzer;
851 Res |= SanitizerKind::FuzzerNoLink;
852 Res &= ~SanitizerKind::CFIMFCall;
853 return Res;
854}
855
856static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL,
857 bool SupportsForcingFramePointer,
858 const char *ExpandChar, const OptTable &Opts) {
859 assert(A->getOption().matches(options::OPT__SLASH_O));
860
861 StringRef OptStr = A->getValue();
862 for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
863 const char &OptChar = *(OptStr.data() + I);
864 switch (OptChar) {
865 default:
866 break;
867 case '1':
868 case '2':
869 case 'x':
870 case 'd':
871 // Ignore /O[12xd] flags that aren't the last one on the command line.
872 // Only the last one gets expanded.
873 if (&OptChar != ExpandChar) {
874 A->claim();
875 break;
876 }
877 if (OptChar == 'd') {
878 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_O0));
879 } else {
880 if (OptChar == '1') {
881 DAL.AddJoinedArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_O), Value: "s");
882 } else if (OptChar == '2' || OptChar == 'x') {
883 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fbuiltin));
884 DAL.AddJoinedArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_O), Value: "3");
885 }
886 if (SupportsForcingFramePointer &&
887 !DAL.hasArgNoClaim(Ids: options::OPT_fno_omit_frame_pointer))
888 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fomit_frame_pointer));
889 if (OptChar == '1' || OptChar == '2')
890 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_ffunction_sections));
891 }
892 break;
893 case 'b':
894 if (I + 1 != E && isdigit(OptStr[I + 1])) {
895 switch (OptStr[I + 1]) {
896 case '0':
897 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fno_inline));
898 break;
899 case '1':
900 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_finline_hint_functions));
901 break;
902 case '2':
903 case '3':
904 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_finline_functions));
905 break;
906 }
907 ++I;
908 }
909 break;
910 case 'g':
911 A->claim();
912 break;
913 case 'i':
914 if (I + 1 != E && OptStr[I + 1] == '-') {
915 ++I;
916 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fno_builtin));
917 } else {
918 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fbuiltin));
919 }
920 break;
921 case 's':
922 DAL.AddJoinedArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_O), Value: "s");
923 break;
924 case 't':
925 DAL.AddJoinedArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_O), Value: "3");
926 break;
927 case 'y': {
928 bool OmitFramePointer = true;
929 if (I + 1 != E && OptStr[I + 1] == '-') {
930 OmitFramePointer = false;
931 ++I;
932 }
933 if (SupportsForcingFramePointer) {
934 if (OmitFramePointer)
935 DAL.AddFlagArg(BaseArg: A,
936 Opt: Opts.getOption(Opt: options::OPT_fomit_frame_pointer));
937 else
938 DAL.AddFlagArg(
939 BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fno_omit_frame_pointer));
940 } else {
941 // Don't warn about /Oy- in x86-64 builds (where
942 // SupportsForcingFramePointer is false). The flag having no effect
943 // there is a compiler-internal optimization, and people shouldn't have
944 // to special-case their build files for x86-64 clang-cl.
945 A->claim();
946 }
947 break;
948 }
949 }
950 }
951}
952
953static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL,
954 const OptTable &Opts) {
955 assert(A->getOption().matches(options::OPT_D));
956
957 StringRef Val = A->getValue();
958 size_t Hash = Val.find(C: '#');
959 if (Hash == StringRef::npos || Hash > Val.find(C: '=')) {
960 DAL.append(A);
961 return;
962 }
963
964 std::string NewVal = std::string(Val);
965 NewVal[Hash] = '=';
966 DAL.AddJoinedArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_D), Value: NewVal);
967}
968
969static void TranslatePermissive(Arg *A, llvm::opt::DerivedArgList &DAL,
970 const OptTable &Opts) {
971 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT__SLASH_Zc_twoPhase_));
972 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_fno_operator_names));
973}
974
975static void TranslatePermissiveMinus(Arg *A, llvm::opt::DerivedArgList &DAL,
976 const OptTable &Opts) {
977 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT__SLASH_Zc_twoPhase));
978 DAL.AddFlagArg(BaseArg: A, Opt: Opts.getOption(Opt: options::OPT_foperator_names));
979}
980
981llvm::opt::DerivedArgList *
982MSVCToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
983 StringRef BoundArch,
984 Action::OffloadKind OFK) const {
985 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
986 const OptTable &Opts = getDriver().getOpts();
987
988 // /Oy and /Oy- don't have an effect on X86-64
989 bool SupportsForcingFramePointer = getArch() != llvm::Triple::x86_64;
990
991 // The -O[12xd] flag actually expands to several flags. We must desugar the
992 // flags so that options embedded can be negated. For example, the '-O2' flag
993 // enables '-Oy'. Expanding '-O2' into its constituent flags allows us to
994 // correctly handle '-O2 -Oy-' where the trailing '-Oy-' disables a single
995 // aspect of '-O2'.
996 //
997 // Note that this expansion logic only applies to the *last* of '[12xd]'.
998
999 // First step is to search for the character we'd like to expand.
1000 const char *ExpandChar = nullptr;
1001 for (Arg *A : Args.filtered(Ids: options::OPT__SLASH_O)) {
1002 StringRef OptStr = A->getValue();
1003 for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
1004 char OptChar = OptStr[I];
1005 char PrevChar = I > 0 ? OptStr[I - 1] : '0';
1006 if (PrevChar == 'b') {
1007 // OptChar does not expand; it's an argument to the previous char.
1008 continue;
1009 }
1010 if (OptChar == '1' || OptChar == '2' || OptChar == 'x' || OptChar == 'd')
1011 ExpandChar = OptStr.data() + I;
1012 }
1013 }
1014
1015 for (Arg *A : Args) {
1016 if (A->getOption().matches(ID: options::OPT__SLASH_O)) {
1017 // The -O flag actually takes an amalgam of other options. For example,
1018 // '/Ogyb2' is equivalent to '/Og' '/Oy' '/Ob2'.
1019 TranslateOptArg(A, DAL&: *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
1020 } else if (A->getOption().matches(ID: options::OPT_D)) {
1021 // Translate -Dfoo#bar into -Dfoo=bar.
1022 TranslateDArg(A, DAL&: *DAL, Opts);
1023 } else if (A->getOption().matches(ID: options::OPT__SLASH_permissive)) {
1024 // Expand /permissive
1025 TranslatePermissive(A, DAL&: *DAL, Opts);
1026 } else if (A->getOption().matches(ID: options::OPT__SLASH_permissive_)) {
1027 // Expand /permissive-
1028 TranslatePermissiveMinus(A, DAL&: *DAL, Opts);
1029 } else if (OFK != Action::OFK_HIP) {
1030 // HIP Toolchain translates input args by itself.
1031 DAL->append(A);
1032 }
1033 }
1034
1035 return DAL;
1036}
1037
1038void MSVCToolChain::addClangTargetOptions(
1039 const ArgList &DriverArgs, ArgStringList &CC1Args,
1040 Action::OffloadKind DeviceOffloadKind) const {
1041 // MSVC STL kindly allows removing all usages of typeid by defining
1042 // _HAS_STATIC_RTTI to 0. Do so, when compiling with -fno-rtti
1043 if (DriverArgs.hasFlag(Pos: options::OPT_fno_rtti, Neg: options::OPT_frtti,
1044 /*Default=*/false))
1045 CC1Args.push_back(Elt: "-D_HAS_STATIC_RTTI=0");
1046
1047 if (Arg *A = DriverArgs.getLastArgNoClaim(Ids: options::OPT_marm64x))
1048 A->ignoreTargetSpecific();
1049}
1050