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