1//===-- CrossWindows.cpp - Cross Windows Tool Chain -----------------------===//
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 "CrossWindows.h"
10#include "CommonArgs.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Driver/Driver.h"
13#include "clang/Driver/Options.h"
14#include "clang/Driver/SanitizerArgs.h"
15#include "llvm/Option/ArgList.h"
16#include "llvm/Support/Path.h"
17
18using namespace clang::driver;
19using namespace clang::driver::toolchains;
20
21using llvm::opt::ArgList;
22using llvm::opt::ArgStringList;
23
24void tools::CrossWindows::Assembler::ConstructJob(
25    Compilation &C, const JobAction &JA, const InputInfo &Output,
26    const InputInfoList &Inputs, const ArgList &Args,
27    const char *LinkingOutput) const {
28  claimNoWarnArgs(Args);
29  const auto &TC =
30      static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
31  ArgStringList CmdArgs;
32  const char *Exec;
33
34  switch (TC.getArch()) {
35  default:
36    llvm_unreachable("unsupported architecture");
37  case llvm::Triple::arm:
38  case llvm::Triple::thumb:
39  case llvm::Triple::aarch64:
40    break;
41  case llvm::Triple::x86:
42    CmdArgs.push_back("--32");
43    break;
44  case llvm::Triple::x86_64:
45    CmdArgs.push_back("--64");
46    break;
47  }
48
49  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
50
51  CmdArgs.push_back("-o");
52  CmdArgs.push_back(Output.getFilename());
53
54  for (const auto &Input : Inputs)
55    CmdArgs.push_back(Input.getFilename());
56
57  const std::string Assembler = TC.GetProgramPath("as");
58  Exec = Args.MakeArgString(Assembler);
59
60  C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
61                                         Exec, CmdArgs, Inputs, Output));
62}
63
64void tools::CrossWindows::Linker::ConstructJob(
65    Compilation &C, const JobAction &JA, const InputInfo &Output,
66    const InputInfoList &Inputs, const ArgList &Args,
67    const char *LinkingOutput) const {
68  const auto &TC =
69      static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
70  const llvm::Triple &T = TC.getTriple();
71  const Driver &D = TC.getDriver();
72  SmallString<128> EntryPoint;
73  ArgStringList CmdArgs;
74  const char *Exec;
75
76  // Silence warning for "clang -g foo.o -o foo"
77  Args.ClaimAllArgs(options::OPT_g_Group);
78  // and "clang -emit-llvm foo.o -o foo"
79  Args.ClaimAllArgs(options::OPT_emit_llvm);
80  // and for "clang -w foo.o -o foo"
81  Args.ClaimAllArgs(options::OPT_w);
82  // Other warning options are already handled somewhere else.
83
84  if (!D.SysRoot.empty())
85    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
86
87  if (Args.hasArg(options::OPT_pie))
88    CmdArgs.push_back("-pie");
89  if (Args.hasArg(options::OPT_rdynamic))
90    CmdArgs.push_back("-export-dynamic");
91  if (Args.hasArg(options::OPT_s))
92    CmdArgs.push_back("--strip-all");
93
94  CmdArgs.push_back("-m");
95  switch (TC.getArch()) {
96  default:
97    D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();
98    break;
99  case llvm::Triple::arm:
100  case llvm::Triple::thumb:
101    // FIXME: this is incorrect for WinCE
102    CmdArgs.push_back("thumb2pe");
103    break;
104  case llvm::Triple::aarch64:
105    CmdArgs.push_back("arm64pe");
106    break;
107  case llvm::Triple::x86:
108    CmdArgs.push_back("i386pe");
109    EntryPoint.append("_");
110    break;
111  case llvm::Triple::x86_64:
112    CmdArgs.push_back("i386pep");
113    break;
114  }
115
116  if (Args.hasArg(options::OPT_shared)) {
117    switch (T.getArch()) {
118    default:
119      llvm_unreachable("unsupported architecture");
120    case llvm::Triple::aarch64:
121    case llvm::Triple::arm:
122    case llvm::Triple::thumb:
123    case llvm::Triple::x86_64:
124      EntryPoint.append("_DllMainCRTStartup");
125      break;
126    case llvm::Triple::x86:
127      EntryPoint.append("_DllMainCRTStartup@12");
128      break;
129    }
130
131    CmdArgs.push_back("-shared");
132    CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
133                                                       : "-Bdynamic");
134
135    CmdArgs.push_back("--enable-auto-image-base");
136
137    CmdArgs.push_back("--entry");
138    CmdArgs.push_back(Args.MakeArgString(EntryPoint));
139  } else {
140    EntryPoint.append("mainCRTStartup");
141
142    CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
143                                                       : "-Bdynamic");
144
145    if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
146      CmdArgs.push_back("--entry");
147      CmdArgs.push_back(Args.MakeArgString(EntryPoint));
148    }
149
150    // FIXME: handle subsystem
151  }
152
153  // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
154  CmdArgs.push_back("--allow-multiple-definition");
155
156  CmdArgs.push_back("-o");
157  CmdArgs.push_back(Output.getFilename());
158
159  if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
160    SmallString<261> ImpLib(Output.getFilename());
161    llvm::sys::path::replace_extension(ImpLib, ".lib");
162
163    CmdArgs.push_back("--out-implib");
164    CmdArgs.push_back(Args.MakeArgString(ImpLib));
165  }
166
167  Args.AddAllArgs(CmdArgs, options::OPT_L);
168  TC.AddFilePathLibArgs(Args, CmdArgs);
169  AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
170
171  if (TC.ShouldLinkCXXStdlib(Args)) {
172    bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
173                     !Args.hasArg(options::OPT_static);
174    if (StaticCXX)
175      CmdArgs.push_back("-Bstatic");
176    TC.AddCXXStdlibLibArgs(Args, CmdArgs);
177    if (StaticCXX)
178      CmdArgs.push_back("-Bdynamic");
179  }
180
181  if (!Args.hasArg(options::OPT_nostdlib)) {
182    if (!Args.hasArg(options::OPT_nodefaultlibs)) {
183      // TODO handle /MT[d] /MD[d]
184      CmdArgs.push_back("-lmsvcrt");
185      AddRunTimeLibs(TC, D, CmdArgs, Args);
186    }
187  }
188
189  if (TC.getSanitizerArgs(Args).needsAsanRt()) {
190    // TODO handle /MT[d] /MD[d]
191    if (Args.hasArg(options::OPT_shared)) {
192      CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
193    } else {
194      for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
195        CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
196      // Make sure the dynamic runtime thunk is not optimized out at link time
197      // to ensure proper SEH handling.
198      CmdArgs.push_back(Args.MakeArgString("--undefined"));
199      CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86
200                                               ? "___asan_seh_interceptor"
201                                               : "__asan_seh_interceptor"));
202    }
203  }
204
205  Exec = Args.MakeArgString(TC.GetLinkerPath());
206
207  C.addCommand(std::make_unique<Command>(JA, *this,
208                                         ResponseFileSupport::AtFileUTF8(),
209                                         Exec, CmdArgs, Inputs, Output));
210}
211
212CrossWindowsToolChain::CrossWindowsToolChain(const Driver &D,
213                                             const llvm::Triple &T,
214                                             const llvm::opt::ArgList &Args)
215    : Generic_GCC(D, T, Args) {}
216
217ToolChain::UnwindTableLevel
218CrossWindowsToolChain::getDefaultUnwindTableLevel(const ArgList &Args) const {
219  // FIXME: all non-x86 targets need unwind tables, however, LLVM currently does
220  // not know how to emit them.
221  return getArch() == llvm::Triple::x86_64 ? UnwindTableLevel::Asynchronous : UnwindTableLevel::None;
222}
223
224bool CrossWindowsToolChain::isPICDefault() const {
225  return getArch() == llvm::Triple::x86_64;
226}
227
228bool CrossWindowsToolChain::isPIEDefault(const llvm::opt::ArgList &Args) const {
229  return getArch() == llvm::Triple::x86_64;
230}
231
232bool CrossWindowsToolChain::isPICDefaultForced() const {
233  return getArch() == llvm::Triple::x86_64;
234}
235
236void CrossWindowsToolChain::
237AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
238                          llvm::opt::ArgStringList &CC1Args) const {
239  const Driver &D = getDriver();
240  const std::string &SysRoot = D.SysRoot;
241
242  auto AddSystemAfterIncludes = [&]() {
243    for (const auto &P : DriverArgs.getAllArgValues(options::OPT_isystem_after))
244      addSystemInclude(DriverArgs, CC1Args, P);
245  };
246
247  if (DriverArgs.hasArg(options::OPT_nostdinc)) {
248    AddSystemAfterIncludes();
249    return;
250  }
251
252  addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
253  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
254    SmallString<128> ResourceDir(D.ResourceDir);
255    llvm::sys::path::append(ResourceDir, "include");
256    addSystemInclude(DriverArgs, CC1Args, ResourceDir);
257  }
258  AddSystemAfterIncludes();
259  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
260}
261
262void CrossWindowsToolChain::
263AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
264                             llvm::opt::ArgStringList &CC1Args) const {
265  const std::string &SysRoot = getDriver().SysRoot;
266
267  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
268      DriverArgs.hasArg(options::OPT_nostdincxx))
269    return;
270
271  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx)
272    addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include/c++/v1");
273}
274
275void CrossWindowsToolChain::
276AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
277                    llvm::opt::ArgStringList &CmdArgs) const {
278  if (GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) {
279    CmdArgs.push_back("-lc++");
280    if (Args.hasArg(options::OPT_fexperimental_library))
281      CmdArgs.push_back("-lc++experimental");
282  }
283}
284
285clang::SanitizerMask CrossWindowsToolChain::getSupportedSanitizers() const {
286  SanitizerMask Res = ToolChain::getSupportedSanitizers();
287  Res |= SanitizerKind::Address;
288  Res |= SanitizerKind::PointerCompare;
289  Res |= SanitizerKind::PointerSubtract;
290  return Res;
291}
292
293Tool *CrossWindowsToolChain::buildLinker() const {
294  return new tools::CrossWindows::Linker(*this);
295}
296
297Tool *CrossWindowsToolChain::buildAssembler() const {
298  return new tools::CrossWindows::Assembler(*this);
299}
300