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