clang/lib/Driver/ToolChains/CrossWindows.cpp

   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
  18 using namespace clang::driver;
  19 using namespace clang::driver::toolchains;
  20
  21 using llvm::opt::ArgList;
  22 using llvm::opt::ArgStringList;
  23
  24 void 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
  64 void 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
 212 CrossWindowsToolChain::CrossWindowsToolChain(const Driver &D,
 213                                              const llvm::Triple &T,
 214                                              const llvm::opt::ArgList &Args)
 215     : Generic_GCC(D, T, Args) {}
 216
 217 ToolChain::UnwindTableLevel
 218 CrossWindowsToolChain::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
 224 bool CrossWindowsToolChain::isPICDefault() const {
 225   return getArch() == llvm::Triple::x86_64;
 226 }
 227
 228 bool CrossWindowsToolChain::isPIEDefault(const llvm::opt::ArgList &Args) const {
 229   return getArch() == llvm::Triple::x86_64;
 230 }
 231
 232 bool CrossWindowsToolChain::isPICDefaultForced() const {
 233   return getArch() == llvm::Triple::x86_64;
 234 }
 235
 236 void CrossWindowsToolChain::
 237 AddClangSystemIncludeArgs(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
 262 void CrossWindowsToolChain::
 263 AddClangCXXStdlibIncludeArgs(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
 275 void CrossWindowsToolChain::
 276 AddCXXStdlibLibArgs(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
 285 clang::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
 293 Tool *CrossWindowsToolChain::buildLinker() const {
 294   return new tools::CrossWindows::Linker(*this);
 295 }
 296
 297 Tool *CrossWindowsToolChain::buildAssembler() const {
 298   return new tools::CrossWindows::Assembler(*this);
 299 }