blob: 6a1566636267443133011bfa68ff6a00c74224d6 [file] [log] [blame]
Daniel Dunbar39176082009-03-20 00:20:03 +00001//===--- ToolChains.cpp - ToolChain Implementations ---------------------*-===//
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 "ToolChains.h"
11
Daniel Dunbarf3cad362009-03-25 04:13:45 +000012#include "clang/Driver/Arg.h"
13#include "clang/Driver/ArgList.h"
Daniel Dunbar0f602de2010-05-20 21:48:38 +000014#include "clang/Driver/Compilation.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000015#include "clang/Driver/Driver.h"
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +000016#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000017#include "clang/Driver/HostInfo.h"
Daniel Dunbar27e738d2009-11-19 00:15:11 +000018#include "clang/Driver/OptTable.h"
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +000019#include "clang/Driver/Option.h"
Daniel Dunbar265e9ef2009-11-19 04:25:22 +000020#include "clang/Driver/Options.h"
Douglas Gregor34916db2010-09-03 17:16:03 +000021#include "clang/Basic/Version.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000022
Daniel Dunbar00577ad2010-08-23 22:35:37 +000023#include "llvm/ADT/SmallString.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000024#include "llvm/ADT/StringExtras.h"
Daniel Dunbar84ec96c2009-09-09 22:33:15 +000025#include "llvm/Support/ErrorHandling.h"
Rafael Espindolac1da9812010-11-07 20:14:31 +000026#include "llvm/Support/MemoryBuffer.h"
Daniel Dunbarec069ed2009-03-25 06:58:31 +000027#include "llvm/Support/raw_ostream.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000028#include "llvm/System/Path.h"
29
Daniel Dunbarf36a06a2009-04-10 21:00:07 +000030#include <cstdlib> // ::getenv
31
Daniel Dunbar39176082009-03-20 00:20:03 +000032using namespace clang::driver;
33using namespace clang::driver::toolchains;
34
Daniel Dunbarf3955282009-09-04 18:34:51 +000035/// Darwin - Darwin tool chain for i386 and x86_64.
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +000036
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000037Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple)
Daniel Dunbarcc8e1892010-01-27 00:56:44 +000038 : ToolChain(Host, Triple), TargetInitialized(false)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +000039{
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000040 // Compute the initial Darwin version based on the host.
41 bool HadExtra;
42 std::string OSName = Triple.getOSName();
43 if (!Driver::GetReleaseVersion(&OSName[6],
44 DarwinVersion[0], DarwinVersion[1],
45 DarwinVersion[2], HadExtra))
46 getDriver().Diag(clang::diag::err_drv_invalid_darwin_version) << OSName;
47
Daniel Dunbar02633b52009-03-26 16:23:12 +000048 llvm::raw_string_ostream(MacosxVersionMin)
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000049 << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.'
50 << DarwinVersion[1];
Daniel Dunbar1d4612b2009-09-18 08:15:13 +000051}
52
Daniel Dunbar41800112010-08-02 05:43:56 +000053types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
54 types::ID Ty = types::lookupTypeForExtension(Ext);
55
56 // Darwin always preprocesses assembly files (unless -x is used explicitly).
57 if (Ty == types::TY_PP_Asm)
58 return types::TY_Asm;
59
60 return Ty;
61}
62
Daniel Dunbarb993f5d2010-09-17 00:24:52 +000063bool Darwin::HasNativeLLVMSupport() const {
64 return true;
65}
66
Daniel Dunbareeff4062010-01-22 02:04:58 +000067// FIXME: Can we tablegen this?
68static const char *GetArmArchForMArch(llvm::StringRef Value) {
69 if (Value == "armv6k")
70 return "armv6";
71
72 if (Value == "armv5tej")
73 return "armv5";
74
75 if (Value == "xscale")
76 return "xscale";
77
78 if (Value == "armv4t")
79 return "armv4t";
80
81 if (Value == "armv7" || Value == "armv7-a" || Value == "armv7-r" ||
82 Value == "armv7-m" || Value == "armv7a" || Value == "armv7r" ||
83 Value == "armv7m")
84 return "armv7";
85
86 return 0;
87}
88
89// FIXME: Can we tablegen this?
90static const char *GetArmArchForMCpu(llvm::StringRef Value) {
91 if (Value == "arm10tdmi" || Value == "arm1020t" || Value == "arm9e" ||
92 Value == "arm946e-s" || Value == "arm966e-s" ||
93 Value == "arm968e-s" || Value == "arm10e" ||
94 Value == "arm1020e" || Value == "arm1022e" || Value == "arm926ej-s" ||
95 Value == "arm1026ej-s")
96 return "armv5";
97
98 if (Value == "xscale")
99 return "xscale";
100
101 if (Value == "arm1136j-s" || Value == "arm1136jf-s" ||
102 Value == "arm1176jz-s" || Value == "arm1176jzf-s")
103 return "armv6";
104
105 if (Value == "cortex-a8" || Value == "cortex-r4" || Value == "cortex-m3")
106 return "armv7";
107
108 return 0;
109}
110
111llvm::StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
112 switch (getTriple().getArch()) {
113 default:
114 return getArchName();
115
116 case llvm::Triple::arm: {
117 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
118 if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
119 return Arch;
120
121 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
122 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
123 return Arch;
124
125 return "arm";
126 }
127 }
128}
129
Daniel Dunbar25b58eb2010-08-02 05:44:07 +0000130DarwinGCC::DarwinGCC(const HostInfo &Host, const llvm::Triple& Triple)
131 : Darwin(Host, Triple)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000132{
Daniel Dunbarc2bda622010-08-02 05:44:01 +0000133 // We can only work with 4.2.1 currently.
134 GCCVersion[0] = 4;
135 GCCVersion[1] = 2;
136 GCCVersion[2] = 1;
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000137
138 // Set up the tool chain paths to match gcc.
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000139 ToolChainDir = "i686-apple-darwin";
Ted Kremenek55bac532009-10-07 03:21:11 +0000140 ToolChainDir += llvm::utostr(DarwinVersion[0]);
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000141 ToolChainDir += "/";
142 ToolChainDir += llvm::utostr(GCCVersion[0]);
143 ToolChainDir += '.';
144 ToolChainDir += llvm::utostr(GCCVersion[1]);
145 ToolChainDir += '.';
146 ToolChainDir += llvm::utostr(GCCVersion[2]);
147
Daniel Dunbar74782b02009-10-20 19:25:43 +0000148 // Try the next major version if that tool chain dir is invalid.
Daniel Dunbar080fb192009-10-22 00:12:00 +0000149 std::string Tmp = "/usr/lib/gcc/" + ToolChainDir;
150 if (!llvm::sys::Path(Tmp).exists()) {
Daniel Dunbar74782b02009-10-20 19:25:43 +0000151 std::string Next = "i686-apple-darwin";
152 Next += llvm::utostr(DarwinVersion[0] + 1);
153 Next += "/";
154 Next += llvm::utostr(GCCVersion[0]);
155 Next += '.';
156 Next += llvm::utostr(GCCVersion[1]);
157 Next += '.';
158 Next += llvm::utostr(GCCVersion[2]);
159
160 // Use that if it exists, otherwise hope the user isn't linking.
161 //
162 // FIXME: Drop dependency on gcc's tool chain.
Daniel Dunbar080fb192009-10-22 00:12:00 +0000163 Tmp = "/usr/lib/gcc/" + Next;
164 if (llvm::sys::Path(Tmp).exists())
Daniel Dunbar74782b02009-10-20 19:25:43 +0000165 ToolChainDir = Next;
166 }
167
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000168 std::string Path;
169 if (getArchName() == "x86_64") {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000170 Path = getDriver().Dir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000171 Path += "/../lib/gcc/";
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000172 Path += ToolChainDir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000173 Path += "/x86_64";
174 getFilePaths().push_back(Path);
175
176 Path = "/usr/lib/gcc/";
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000177 Path += ToolChainDir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000178 Path += "/x86_64";
179 getFilePaths().push_back(Path);
180 }
Mike Stump1eb44332009-09-09 15:08:12 +0000181
Daniel Dunbaree788e72009-12-21 18:54:17 +0000182 Path = getDriver().Dir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000183 Path += "/../lib/gcc/";
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000184 Path += ToolChainDir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000185 getFilePaths().push_back(Path);
186
187 Path = "/usr/lib/gcc/";
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000188 Path += ToolChainDir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000189 getFilePaths().push_back(Path);
190
Daniel Dunbaree788e72009-12-21 18:54:17 +0000191 Path = getDriver().Dir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000192 Path += "/../libexec/gcc/";
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000193 Path += ToolChainDir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000194 getProgramPaths().push_back(Path);
195
196 Path = "/usr/libexec/gcc/";
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000197 Path += ToolChainDir;
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000198 getProgramPaths().push_back(Path);
199
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000200 getProgramPaths().push_back(getDriver().getInstalledDir());
201 if (getDriver().getInstalledDir() != getDriver().Dir)
202 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000203}
204
Daniel Dunbarf3955282009-09-04 18:34:51 +0000205Darwin::~Darwin() {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000206 // Free tool implementations.
207 for (llvm::DenseMap<unsigned, Tool*>::iterator
208 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
209 delete it->second;
210}
211
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000212std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args) const {
213 llvm::Triple Triple(ComputeLLVMTriple(Args));
214
215 // If the target isn't initialized (e.g., an unknown Darwin platform, return
216 // the default triple).
217 if (!isTargetInitialized())
218 return Triple.getTriple();
219
220 unsigned Version[3];
221 getTargetVersion(Version);
222
223 // Mangle the target version into the OS triple component. For historical
224 // reasons that make little sense, the version passed here is the "darwin"
225 // version, which drops the 10 and offsets by 4. See inverse code when
226 // setting the OS version preprocessor define.
227 if (!isTargetIPhoneOS()) {
228 Version[0] = Version[1] + 4;
229 Version[1] = Version[2];
230 Version[2] = 0;
231 } else {
232 // Use the environment to communicate that we are targetting iPhoneOS.
233 Triple.setEnvironmentName("iphoneos");
234 }
235
236 llvm::SmallString<16> Str;
237 llvm::raw_svector_ostream(Str) << "darwin" << Version[0]
238 << "." << Version[1] << "." << Version[2];
239 Triple.setOSName(Str.str());
240
241 return Triple.getTriple();
242}
243
Daniel Dunbarf3955282009-09-04 18:34:51 +0000244Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA) const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000245 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +0000246 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000247 Key = Action::AnalyzeJobClass;
248 else
249 Key = JA.getKind();
250
Daniel Dunbar0f602de2010-05-20 21:48:38 +0000251 // FIXME: This doesn't belong here, but ideally we will support static soon
252 // anyway.
253 bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
254 C.getArgs().hasArg(options::OPT_static) ||
255 C.getArgs().hasArg(options::OPT_fapple_kext));
256 bool IsIADefault = IsIntegratedAssemblerDefault() && !HasStatic;
257 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
258 options::OPT_no_integrated_as,
259 IsIADefault);
260
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000261 Tool *&T = Tools[Key];
262 if (!T) {
263 switch (Key) {
264 case Action::InputClass:
265 case Action::BindArchClass:
266 assert(0 && "Invalid tool kind.");
267 case Action::PreprocessJobClass:
Daniel Dunbar9120f172009-03-29 22:27:40 +0000268 T = new tools::darwin::Preprocess(*this); break;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000269 case Action::AnalyzeJobClass:
270 T = new tools::Clang(*this); break;
Daniel Dunbar9120f172009-03-29 22:27:40 +0000271 case Action::PrecompileJobClass:
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000272 case Action::CompileJobClass:
Daniel Dunbar9120f172009-03-29 22:27:40 +0000273 T = new tools::darwin::Compile(*this); break;
Daniel Dunbar0f602de2010-05-20 21:48:38 +0000274 case Action::AssembleJobClass: {
275 if (UseIntegratedAs)
276 T = new tools::ClangAs(*this);
277 else
278 T = new tools::darwin::Assemble(*this);
279 break;
280 }
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000281 case Action::LinkJobClass:
Daniel Dunbar8f289622009-09-04 17:39:02 +0000282 T = new tools::darwin::Link(*this); break;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000283 case Action::LipoJobClass:
284 T = new tools::darwin::Lipo(*this); break;
Daniel Dunbar6e0f2542010-06-04 18:28:36 +0000285 case Action::DsymutilJobClass:
286 T = new tools::darwin::Dsymutil(*this); break;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000287 }
288 }
289
290 return *T;
291}
292
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000293void DarwinGCC::AddLinkSearchPathArgs(const ArgList &Args,
294 ArgStringList &CmdArgs) const {
Daniel Dunbare3c153a2010-04-10 18:18:57 +0000295 std::string Tmp;
296
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000297 // FIXME: Derive these correctly.
298 if (getArchName() == "x86_64") {
299 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
300 "/x86_64"));
301 // Intentionally duplicated for (temporary) gcc bug compatibility.
302 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
303 "/x86_64"));
304 }
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000305
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000306 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/" + ToolChainDir));
Daniel Dunbare3c153a2010-04-10 18:18:57 +0000307
308 Tmp = getDriver().Dir + "/../lib/gcc/" + ToolChainDir;
309 if (llvm::sys::Path(Tmp).exists())
310 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
311 Tmp = getDriver().Dir + "/../lib/gcc";
312 if (llvm::sys::Path(Tmp).exists())
313 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000314 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir));
315 // Intentionally duplicated for (temporary) gcc bug compatibility.
316 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir));
Daniel Dunbare3c153a2010-04-10 18:18:57 +0000317 Tmp = getDriver().Dir + "/../lib/" + ToolChainDir;
318 if (llvm::sys::Path(Tmp).exists())
319 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
320 Tmp = getDriver().Dir + "/../lib";
321 if (llvm::sys::Path(Tmp).exists())
322 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
Daniel Dunbar6b200b22009-09-18 08:14:36 +0000323 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
324 "/../../../" + ToolChainDir));
325 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
326 "/../../.."));
327}
328
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000329void DarwinGCC::AddLinkRuntimeLibArgs(const ArgList &Args,
330 ArgStringList &CmdArgs) const {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000331 // Note that this routine is only used for targetting OS X.
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000332
333 // Derived from libgcc and lib specs but refactored.
334 if (Args.hasArg(options::OPT_static)) {
335 CmdArgs.push_back("-lgcc_static");
336 } else {
337 if (Args.hasArg(options::OPT_static_libgcc)) {
338 CmdArgs.push_back("-lgcc_eh");
339 } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) {
340 // Derived from darwin_iphoneos_libgcc spec.
Daniel Dunbar251ca6c2010-01-27 00:56:37 +0000341 if (isTargetIPhoneOS()) {
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000342 CmdArgs.push_back("-lgcc_s.1");
343 } else {
344 CmdArgs.push_back("-lgcc_s.10.5");
345 }
346 } else if (Args.hasArg(options::OPT_shared_libgcc) ||
Daniel Dunbar8a0d94d2010-01-10 00:46:10 +0000347 Args.hasFlag(options::OPT_fexceptions,
348 options::OPT_fno_exceptions) ||
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000349 Args.hasArg(options::OPT_fgnu_runtime)) {
350 // FIXME: This is probably broken on 10.3?
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000351 if (isMacosxVersionLT(10, 5))
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000352 CmdArgs.push_back("-lgcc_s.10.4");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000353 else if (isMacosxVersionLT(10, 6))
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000354 CmdArgs.push_back("-lgcc_s.10.5");
355 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000356 if (isMacosxVersionLT(10, 3, 9))
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000357 ; // Do nothing.
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000358 else if (isMacosxVersionLT(10, 5))
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000359 CmdArgs.push_back("-lgcc_s.10.4");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000360 else if (isMacosxVersionLT(10, 6))
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000361 CmdArgs.push_back("-lgcc_s.10.5");
362 }
363
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000364 if (isTargetIPhoneOS() || isMacosxVersionLT(10, 6)) {
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000365 CmdArgs.push_back("-lgcc");
366 CmdArgs.push_back("-lSystem");
367 } else {
368 CmdArgs.push_back("-lSystem");
369 CmdArgs.push_back("-lgcc");
370 }
371 }
372}
373
Daniel Dunbar25b58eb2010-08-02 05:44:07 +0000374DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple)
375 : Darwin(Host, Triple)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000376{
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000377 getProgramPaths().push_back(getDriver().getInstalledDir());
378 if (getDriver().getInstalledDir() != getDriver().Dir)
379 getProgramPaths().push_back(getDriver().Dir);
380
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000381 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000382 getProgramPaths().push_back(getDriver().getInstalledDir());
383 if (getDriver().getInstalledDir() != getDriver().Dir)
384 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000385
386 // For fallback, we need to know how to find the GCC cc1 executables, so we
387 // also add the GCC libexec paths. This is legiy code that can be removed once
388 // fallback is no longer useful.
389 std::string ToolChainDir = "i686-apple-darwin";
390 ToolChainDir += llvm::utostr(DarwinVersion[0]);
391 ToolChainDir += "/4.2.1";
392
393 std::string Path = getDriver().Dir;
394 Path += "/../libexec/gcc/";
395 Path += ToolChainDir;
396 getProgramPaths().push_back(Path);
397
398 Path = "/usr/libexec/gcc/";
399 Path += ToolChainDir;
400 getProgramPaths().push_back(Path);
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000401}
402
403void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
404 ArgStringList &CmdArgs) const {
405 // The Clang toolchain uses explicit paths for internal libraries.
Daniel Dunbar424b6612010-06-30 23:56:13 +0000406
407 // Unfortunately, we still might depend on a few of the libraries that are
408 // only available in the gcc library directory (in particular
409 // libstdc++.dylib). For now, hardcode the path to the known install location.
410 llvm::sys::Path P(getDriver().Dir);
411 P.eraseComponent(); // .../usr/bin -> ../usr
412 P.appendComponent("lib");
413 P.appendComponent("gcc");
414 switch (getTriple().getArch()) {
415 default:
416 assert(0 && "Invalid Darwin arch!");
417 case llvm::Triple::x86:
418 case llvm::Triple::x86_64:
419 P.appendComponent("i686-apple-darwin10");
420 break;
421 case llvm::Triple::arm:
422 case llvm::Triple::thumb:
423 P.appendComponent("arm-apple-darwin10");
424 break;
425 case llvm::Triple::ppc:
426 case llvm::Triple::ppc64:
427 P.appendComponent("powerpc-apple-darwin10");
428 break;
429 }
430 P.appendComponent("4.2.1");
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000431
432 // Determine the arch specific GCC subdirectory.
433 const char *ArchSpecificDir = 0;
434 switch (getTriple().getArch()) {
435 default:
436 break;
437 case llvm::Triple::arm:
Daniel Dunbar3a0e3922010-08-26 00:55:52 +0000438 case llvm::Triple::thumb: {
439 std::string Triple = ComputeLLVMTriple(Args);
440 llvm::StringRef TripleStr = Triple;
441 if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5"))
442 ArchSpecificDir = "v5";
443 else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6"))
444 ArchSpecificDir = "v6";
445 else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7"))
446 ArchSpecificDir = "v7";
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000447 break;
Daniel Dunbar3a0e3922010-08-26 00:55:52 +0000448 }
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000449 case llvm::Triple::ppc64:
450 ArchSpecificDir = "ppc64";
451 break;
452 case llvm::Triple::x86_64:
453 ArchSpecificDir = "x86_64";
454 break;
455 }
456
457 if (ArchSpecificDir) {
458 P.appendComponent(ArchSpecificDir);
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000459 if (P.exists())
460 CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
461 P.eraseComponent();
462 }
463
Daniel Dunbar424b6612010-06-30 23:56:13 +0000464 if (P.exists())
465 CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000466}
467
468void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
469 ArgStringList &CmdArgs) const {
Daniel Dunbareec99102010-01-22 03:38:14 +0000470 // Darwin doesn't support real static executables, don't link any runtime
471 // libraries with -static.
472 if (Args.hasArg(options::OPT_static))
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000473 return;
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000474
475 // Reject -static-libgcc for now, we can deal with this when and if someone
476 // cares. This is useful in situations where someone wants to statically link
477 // something like libstdc++, and needs its runtime support routines.
478 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000479 getDriver().Diag(clang::diag::err_drv_unsupported_opt)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000480 << A->getAsString(Args);
481 return;
482 }
483
Daniel Dunbareec99102010-01-22 03:38:14 +0000484 // Otherwise link libSystem, then the dynamic runtime library, and finally any
485 // target specific static runtime library.
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000486 CmdArgs.push_back("-lSystem");
Daniel Dunbareec99102010-01-22 03:38:14 +0000487
488 // Select the dynamic runtime library and the target specific static library.
489 const char *DarwinStaticLib = 0;
Daniel Dunbar251ca6c2010-01-27 00:56:37 +0000490 if (isTargetIPhoneOS()) {
Daniel Dunbareec99102010-01-22 03:38:14 +0000491 CmdArgs.push_back("-lgcc_s.1");
492
493 // We may need some static functions for armv6/thumb which are required to
494 // be in the same linkage unit as their caller.
495 if (getDarwinArchName(Args) == "armv6")
496 DarwinStaticLib = "libclang_rt.armv6.a";
497 } else {
Daniel Dunbareec99102010-01-22 03:38:14 +0000498 // The dynamic runtime library was merged with libSystem for 10.6 and
499 // beyond; only 10.4 and 10.5 need an additional runtime library.
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000500 if (isMacosxVersionLT(10, 5))
Daniel Dunbareec99102010-01-22 03:38:14 +0000501 CmdArgs.push_back("-lgcc_s.10.4");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000502 else if (isMacosxVersionLT(10, 6))
Daniel Dunbareec99102010-01-22 03:38:14 +0000503 CmdArgs.push_back("-lgcc_s.10.5");
504
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000505 // For OS X, we thought we would only need a static runtime library when
506 // targetting 10.4, to provide versions of the static functions which were
507 // omitted from 10.4.dylib.
508 //
509 // Unfortunately, that turned out to not be true, because Darwin system
510 // headers can still use eprintf on i386, and it is not exported from
511 // libSystem. Therefore, we still must provide a runtime library just for
512 // the tiny tiny handful of projects that *might* use that symbol.
513 if (isMacosxVersionLT(10, 5)) {
Daniel Dunbareec99102010-01-22 03:38:14 +0000514 DarwinStaticLib = "libclang_rt.10.4.a";
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000515 } else {
516 if (getTriple().getArch() == llvm::Triple::x86)
517 DarwinStaticLib = "libclang_rt.eprintf.a";
518 }
Daniel Dunbareec99102010-01-22 03:38:14 +0000519 }
520
521 /// Add the target specific static library, if needed.
522 if (DarwinStaticLib) {
523 llvm::sys::Path P(getDriver().ResourceDir);
524 P.appendComponent("lib");
525 P.appendComponent("darwin");
526 P.appendComponent(DarwinStaticLib);
527
528 // For now, allow missing resource libraries to support developers who may
529 // not have compiler-rt checked out or integrated into their build.
Daniel Dunbar362ed702010-10-11 23:31:07 +0000530 if (P.exists())
Daniel Dunbareec99102010-01-22 03:38:14 +0000531 CmdArgs.push_back(Args.MakeArgString(P.str()));
532 }
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000533}
534
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000535void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000536 const OptTable &Opts = getDriver().getOpts();
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000537
Daniel Dunbar26031372010-01-27 00:56:25 +0000538 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
539 Arg *iPhoneVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
Daniel Dunbarff8857a2009-04-10 20:11:50 +0000540 if (OSXVersion && iPhoneVersion) {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000541 getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with)
Daniel Dunbarff8857a2009-04-10 20:11:50 +0000542 << OSXVersion->getAsString(Args)
Mike Stump1eb44332009-09-09 15:08:12 +0000543 << iPhoneVersion->getAsString(Args);
Daniel Dunbar26031372010-01-27 00:56:25 +0000544 iPhoneVersion = 0;
Daniel Dunbarff8857a2009-04-10 20:11:50 +0000545 } else if (!OSXVersion && !iPhoneVersion) {
Daniel Dunbar816bc312010-01-26 01:45:19 +0000546 // If neither OS X nor iPhoneOS targets were specified, check for
547 // environment defines.
548 const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET");
549 const char *iPhoneOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET");
Daniel Dunbarf36a06a2009-04-10 21:00:07 +0000550
Daniel Dunbar816bc312010-01-26 01:45:19 +0000551 // Ignore empty strings.
552 if (OSXTarget && OSXTarget[0] == '\0')
553 OSXTarget = 0;
554 if (iPhoneOSTarget && iPhoneOSTarget[0] == '\0')
555 iPhoneOSTarget = 0;
556
Daniel Dunbar39053672010-02-02 17:31:12 +0000557 // Diagnose conflicting deployment targets, and choose default platform
558 // based on the tool chain.
559 //
560 // FIXME: Don't hardcode default here.
561 if (OSXTarget && iPhoneOSTarget) {
562 // FIXME: We should see if we can get away with warning or erroring on
563 // this. Perhaps put under -pedantic?
564 if (getTriple().getArch() == llvm::Triple::arm ||
565 getTriple().getArch() == llvm::Triple::thumb)
Daniel Dunbar84d1e6e2010-03-20 08:47:42 +0000566 OSXTarget = 0;
Daniel Dunbar39053672010-02-02 17:31:12 +0000567 else
Daniel Dunbar84d1e6e2010-03-20 08:47:42 +0000568 iPhoneOSTarget = 0;
Daniel Dunbar39053672010-02-02 17:31:12 +0000569 }
Daniel Dunbar1a3c1d92010-01-29 17:02:25 +0000570
Daniel Dunbar39053672010-02-02 17:31:12 +0000571 if (OSXTarget) {
Daniel Dunbar30392de2009-09-04 18:35:21 +0000572 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000573 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
574 Args.append(OSXVersion);
Daniel Dunbar816bc312010-01-26 01:45:19 +0000575 } else if (iPhoneOSTarget) {
Daniel Dunbar30392de2009-09-04 18:35:21 +0000576 const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000577 iPhoneVersion = Args.MakeJoinedArg(0, O, iPhoneOSTarget);
578 Args.append(iPhoneVersion);
Daniel Dunbar816bc312010-01-26 01:45:19 +0000579 } else {
Daniel Dunbar2bb38d02010-07-15 16:18:06 +0000580 // Otherwise, assume we are targeting OS X.
581 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000582 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
583 Args.append(OSXVersion);
Daniel Dunbar30392de2009-09-04 18:35:21 +0000584 }
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000585 }
Mike Stump1eb44332009-09-09 15:08:12 +0000586
Daniel Dunbar26031372010-01-27 00:56:25 +0000587 // Set the tool chain target information.
588 unsigned Major, Minor, Micro;
589 bool HadExtra;
590 if (OSXVersion) {
591 assert(!iPhoneVersion && "Unknown target platform!");
592 if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
593 Micro, HadExtra) || HadExtra ||
594 Major != 10 || Minor >= 10 || Micro >= 10)
595 getDriver().Diag(clang::diag::err_drv_invalid_version_number)
596 << OSXVersion->getAsString(Args);
597 } else {
598 assert(iPhoneVersion && "Unknown target platform!");
599 if (!Driver::GetReleaseVersion(iPhoneVersion->getValue(Args), Major, Minor,
600 Micro, HadExtra) || HadExtra ||
601 Major >= 10 || Minor >= 100 || Micro >= 100)
602 getDriver().Diag(clang::diag::err_drv_invalid_version_number)
603 << iPhoneVersion->getAsString(Args);
604 }
605 setTarget(iPhoneVersion, Major, Minor, Micro);
Daniel Dunbarc0e665e2010-07-19 17:11:33 +0000606}
607
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000608void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000609 ArgStringList &CmdArgs) const {
610 CXXStdlibType Type = GetCXXStdlibType(Args);
611
612 switch (Type) {
613 case ToolChain::CST_Libcxx:
614 CmdArgs.push_back("-lc++");
615 break;
616
617 case ToolChain::CST_Libstdcxx: {
618 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
619 // it was previously found in the gcc lib dir. However, for all the Darwin
620 // platforms we care about it was -lstdc++.6, so we search for that
621 // explicitly if we can't see an obvious -lstdc++ candidate.
622
623 // Check in the sysroot first.
624 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
625 llvm::sys::Path P(A->getValue(Args));
626 P.appendComponent("usr");
627 P.appendComponent("lib");
628 P.appendComponent("libstdc++.dylib");
629
630 if (!P.exists()) {
631 P.eraseComponent();
632 P.appendComponent("libstdc++.6.dylib");
633 if (P.exists()) {
634 CmdArgs.push_back(Args.MakeArgString(P.str()));
635 return;
636 }
637 }
638 }
639
640 // Otherwise, look in the root.
641 if (!llvm::sys::Path("/usr/lib/libstdc++.dylib").exists() &&
642 llvm::sys::Path("/usr/lib/libstdc++.6.dylib").exists()) {
643 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
644 return;
645 }
646
647 // Otherwise, let the linker search.
648 CmdArgs.push_back("-lstdc++");
649 break;
650 }
651 }
652}
653
Shantonu Sen7433fed2010-09-17 18:39:08 +0000654void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
655 ArgStringList &CmdArgs) const {
656
657 // For Darwin platforms, use the compiler-rt-based support library
658 // instead of the gcc-provided one (which is also incidentally
659 // only present in the gcc lib dir, which makes it hard to find).
660
661 llvm::sys::Path P(getDriver().ResourceDir);
662 P.appendComponent("lib");
663 P.appendComponent("darwin");
664 P.appendComponent("libclang_rt.cc_kext.a");
665
666 // For now, allow missing resource libraries to support developers who may
667 // not have compiler-rt checked out or integrated into their build.
Daniel Dunbar362ed702010-10-11 23:31:07 +0000668 if (P.exists())
Shantonu Sen7433fed2010-09-17 18:39:08 +0000669 CmdArgs.push_back(Args.MakeArgString(P.str()));
670}
671
Daniel Dunbarc0e665e2010-07-19 17:11:33 +0000672DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
673 const char *BoundArch) const {
674 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
675 const OptTable &Opts = getDriver().getOpts();
676
677 // FIXME: We really want to get out of the tool chain level argument
678 // translation business, as it makes the driver functionality much
679 // more opaque. For now, we follow gcc closely solely for the
680 // purpose of easily achieving feature parity & testability. Once we
681 // have something that works, we should reevaluate each translation
682 // and try to push it down into tool specific logic.
Daniel Dunbar26031372010-01-27 00:56:25 +0000683
Daniel Dunbar279c1db2010-06-11 22:00:26 +0000684 for (ArgList::const_iterator it = Args.begin(),
685 ie = Args.end(); it != ie; ++it) {
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000686 Arg *A = *it;
687
688 if (A->getOption().matches(options::OPT_Xarch__)) {
689 // FIXME: Canonicalize name.
690 if (getArchName() != A->getValue(Args, 0))
691 continue;
692
Daniel Dunbar0e100312010-06-14 21:23:08 +0000693 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
694 unsigned Prev = Index;
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000695 Arg *XarchArg = Opts.ParseOneArg(Args, Index);
Mike Stump1eb44332009-09-09 15:08:12 +0000696
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000697 // If the argument parsing failed or more than one argument was
698 // consumed, the -Xarch_ argument's parameter tried to consume
699 // extra arguments. Emit an error and ignore.
700 //
701 // We also want to disallow any options which would alter the
702 // driver behavior; that isn't going to work in our model. We
703 // use isDriverOption() as an approximation, although things
704 // like -O4 are going to slip through.
Mike Stump1eb44332009-09-09 15:08:12 +0000705 if (!XarchArg || Index > Prev + 1 ||
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000706 XarchArg->getOption().isDriverOption()) {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000707 getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument)
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000708 << A->getAsString(Args);
709 continue;
710 }
711
Daniel Dunbar478edc22009-03-29 22:29:05 +0000712 XarchArg->setBaseArg(A);
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000713 A = XarchArg;
Daniel Dunbar0e100312010-06-14 21:23:08 +0000714
715 DAL->AddSynthesizedArg(A);
Mike Stump1eb44332009-09-09 15:08:12 +0000716 }
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000717
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000718 // Sob. These is strictly gcc compatible for the time being. Apple
719 // gcc translates options twice, which means that self-expanding
720 // options add duplicates.
Daniel Dunbar9e1f9822009-11-19 04:14:53 +0000721 switch ((options::ID) A->getOption().getID()) {
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000722 default:
723 DAL->append(A);
724 break;
725
726 case options::OPT_mkernel:
727 case options::OPT_fapple_kext:
728 DAL->append(A);
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000729 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
730 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000731 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000732
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000733 case options::OPT_dependency_file:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000734 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
735 A->getValue(Args));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000736 break;
737
738 case options::OPT_gfull:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000739 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
740 DAL->AddFlagArg(A,
741 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000742 break;
743
744 case options::OPT_gused:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000745 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
746 DAL->AddFlagArg(A,
747 Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000748 break;
749
750 case options::OPT_fterminated_vtables:
751 case options::OPT_findirect_virtual_calls:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000752 DAL->AddFlagArg(A, Opts.getOption(options::OPT_fapple_kext));
753 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000754 break;
755
756 case options::OPT_shared:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000757 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000758 break;
759
760 case options::OPT_fconstant_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000761 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000762 break;
763
764 case options::OPT_fno_constant_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000765 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000766 break;
767
768 case options::OPT_Wnonportable_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000769 DAL->AddFlagArg(A,
770 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000771 break;
772
773 case options::OPT_Wno_nonportable_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000774 DAL->AddFlagArg(A,
775 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000776 break;
777
778 case options::OPT_fpascal_strings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000779 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000780 break;
781
782 case options::OPT_fno_pascal_strings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000783 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000784 break;
785 }
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000786 }
787
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000788 if (getTriple().getArch() == llvm::Triple::x86 ||
789 getTriple().getArch() == llvm::Triple::x86_64)
Daniel Dunbare4bdae72009-11-19 04:00:53 +0000790 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000791 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000792
793 // Add the arch options based on the particular spelling of -arch, to match
794 // how the driver driver works.
795 if (BoundArch) {
796 llvm::StringRef Name = BoundArch;
797 const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
798 const Option *MArch = Opts.getOption(options::OPT_march_EQ);
799
800 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
801 // which defines the list of which architectures we accept.
802 if (Name == "ppc")
803 ;
804 else if (Name == "ppc601")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000805 DAL->AddJoinedArg(0, MCpu, "601");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000806 else if (Name == "ppc603")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000807 DAL->AddJoinedArg(0, MCpu, "603");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000808 else if (Name == "ppc604")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000809 DAL->AddJoinedArg(0, MCpu, "604");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000810 else if (Name == "ppc604e")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000811 DAL->AddJoinedArg(0, MCpu, "604e");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000812 else if (Name == "ppc750")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000813 DAL->AddJoinedArg(0, MCpu, "750");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000814 else if (Name == "ppc7400")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000815 DAL->AddJoinedArg(0, MCpu, "7400");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000816 else if (Name == "ppc7450")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000817 DAL->AddJoinedArg(0, MCpu, "7450");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000818 else if (Name == "ppc970")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000819 DAL->AddJoinedArg(0, MCpu, "970");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000820
821 else if (Name == "ppc64")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000822 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000823
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000824 else if (Name == "i386")
825 ;
826 else if (Name == "i486")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000827 DAL->AddJoinedArg(0, MArch, "i486");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000828 else if (Name == "i586")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000829 DAL->AddJoinedArg(0, MArch, "i586");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000830 else if (Name == "i686")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000831 DAL->AddJoinedArg(0, MArch, "i686");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000832 else if (Name == "pentium")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000833 DAL->AddJoinedArg(0, MArch, "pentium");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000834 else if (Name == "pentium2")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000835 DAL->AddJoinedArg(0, MArch, "pentium2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000836 else if (Name == "pentpro")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000837 DAL->AddJoinedArg(0, MArch, "pentiumpro");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000838 else if (Name == "pentIIm3")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000839 DAL->AddJoinedArg(0, MArch, "pentium2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000840
841 else if (Name == "x86_64")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000842 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000843
844 else if (Name == "arm")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000845 DAL->AddJoinedArg(0, MArch, "armv4t");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000846 else if (Name == "armv4t")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000847 DAL->AddJoinedArg(0, MArch, "armv4t");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000848 else if (Name == "armv5")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000849 DAL->AddJoinedArg(0, MArch, "armv5tej");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000850 else if (Name == "xscale")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000851 DAL->AddJoinedArg(0, MArch, "xscale");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000852 else if (Name == "armv6")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000853 DAL->AddJoinedArg(0, MArch, "armv6k");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000854 else if (Name == "armv7")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000855 DAL->AddJoinedArg(0, MArch, "armv7a");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000856
857 else
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +0000858 llvm_unreachable("invalid Darwin arch");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000859 }
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000860
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000861 // Add an explicit version min argument for the deployment target. We do this
862 // after argument translation because -Xarch_ arguments may add a version min
863 // argument.
864 AddDeploymentTarget(*DAL);
865
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000866 return DAL;
Mike Stump1eb44332009-09-09 15:08:12 +0000867}
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000868
Daniel Dunbarf3955282009-09-04 18:34:51 +0000869bool Darwin::IsUnwindTablesDefault() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000870 // FIXME: Gross; we should probably have some separate target
871 // definition, possibly even reusing the one in clang.
872 return getArchName() == "x86_64";
873}
874
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +0000875bool Darwin::UseDwarfDebugFlags() const {
876 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
877 return S[0] != '\0';
878 return false;
879}
880
Daniel Dunbarb2987d12010-02-10 18:49:11 +0000881bool Darwin::UseSjLjExceptions() const {
882 // Darwin uses SjLj exceptions on ARM.
883 return (getTriple().getArch() == llvm::Triple::arm ||
884 getTriple().getArch() == llvm::Triple::thumb);
885}
886
Daniel Dunbarf3955282009-09-04 18:34:51 +0000887const char *Darwin::GetDefaultRelocationModel() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000888 return "pic";
889}
890
Daniel Dunbarf3955282009-09-04 18:34:51 +0000891const char *Darwin::GetForcedPicModel() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000892 if (getArchName() == "x86_64")
893 return "pic";
894 return 0;
895}
896
Daniel Dunbar43a9b322010-04-10 16:20:23 +0000897bool Darwin::SupportsObjCGC() const {
898 // Garbage collection is supported everywhere except on iPhone OS.
899 return !isTargetIPhoneOS();
900}
901
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000902std::string
903Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args) const {
904 return ComputeLLVMTriple(Args);
905}
906
Daniel Dunbar39176082009-03-20 00:20:03 +0000907/// Generic_GCC - A tool chain using the 'gcc' command to perform
908/// all subcommands; this relies on gcc translating the majority of
909/// command line options.
910
Daniel Dunbarcb8ab232009-05-22 02:53:45 +0000911Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
Mike Stump1eb44332009-09-09 15:08:12 +0000912 : ToolChain(Host, Triple) {
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000913 getProgramPaths().push_back(getDriver().getInstalledDir());
914 if (getDriver().getInstalledDir() != getDriver().Dir.c_str())
915 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000916}
917
Daniel Dunbar39176082009-03-20 00:20:03 +0000918Generic_GCC::~Generic_GCC() {
919 // Free tool implementations.
920 for (llvm::DenseMap<unsigned, Tool*>::iterator
921 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
922 delete it->second;
923}
924
Mike Stump1eb44332009-09-09 15:08:12 +0000925Tool &Generic_GCC::SelectTool(const Compilation &C,
Daniel Dunbar39176082009-03-20 00:20:03 +0000926 const JobAction &JA) const {
927 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +0000928 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar39176082009-03-20 00:20:03 +0000929 Key = Action::AnalyzeJobClass;
930 else
931 Key = JA.getKind();
932
933 Tool *&T = Tools[Key];
934 if (!T) {
935 switch (Key) {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000936 case Action::InputClass:
937 case Action::BindArchClass:
Daniel Dunbar39176082009-03-20 00:20:03 +0000938 assert(0 && "Invalid tool kind.");
939 case Action::PreprocessJobClass:
940 T = new tools::gcc::Preprocess(*this); break;
941 case Action::PrecompileJobClass:
942 T = new tools::gcc::Precompile(*this); break;
943 case Action::AnalyzeJobClass:
944 T = new tools::Clang(*this); break;
945 case Action::CompileJobClass:
946 T = new tools::gcc::Compile(*this); break;
947 case Action::AssembleJobClass:
948 T = new tools::gcc::Assemble(*this); break;
949 case Action::LinkJobClass:
950 T = new tools::gcc::Link(*this); break;
Mike Stump1eb44332009-09-09 15:08:12 +0000951
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000952 // This is a bit ungeneric, but the only platform using a driver
953 // driver is Darwin.
954 case Action::LipoJobClass:
955 T = new tools::darwin::Lipo(*this); break;
Daniel Dunbar6e0f2542010-06-04 18:28:36 +0000956 case Action::DsymutilJobClass:
957 T = new tools::darwin::Dsymutil(*this); break;
Daniel Dunbar39176082009-03-20 00:20:03 +0000958 }
959 }
960
961 return *T;
962}
963
Daniel Dunbar39176082009-03-20 00:20:03 +0000964bool Generic_GCC::IsUnwindTablesDefault() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000965 // FIXME: Gross; we should probably have some separate target
966 // definition, possibly even reusing the one in clang.
Daniel Dunbar39176082009-03-20 00:20:03 +0000967 return getArchName() == "x86_64";
968}
969
970const char *Generic_GCC::GetDefaultRelocationModel() const {
971 return "static";
972}
973
974const char *Generic_GCC::GetForcedPicModel() const {
975 return 0;
976}
Daniel Dunbarf3cad362009-03-25 04:13:45 +0000977
Chris Lattner3a47c4e2010-03-04 21:07:38 +0000978/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
979/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
980/// Currently does not support anything else but compilation.
981
982TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
983 : ToolChain(Host, Triple) {
984 // Path mangling to find libexec
985 std::string Path(getDriver().Dir);
986
987 Path += "/../libexec";
988 getProgramPaths().push_back(Path);
989}
990
991TCEToolChain::~TCEToolChain() {
992 for (llvm::DenseMap<unsigned, Tool*>::iterator
993 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
994 delete it->second;
995}
996
997bool TCEToolChain::IsMathErrnoDefault() const {
998 return true;
999}
1000
1001bool TCEToolChain::IsUnwindTablesDefault() const {
1002 return false;
1003}
1004
1005const char *TCEToolChain::GetDefaultRelocationModel() const {
1006 return "static";
1007}
1008
1009const char *TCEToolChain::GetForcedPicModel() const {
1010 return 0;
1011}
1012
1013Tool &TCEToolChain::SelectTool(const Compilation &C,
1014 const JobAction &JA) const {
1015 Action::ActionClass Key;
1016 Key = Action::AnalyzeJobClass;
1017
1018 Tool *&T = Tools[Key];
1019 if (!T) {
1020 switch (Key) {
1021 case Action::PreprocessJobClass:
1022 T = new tools::gcc::Preprocess(*this); break;
1023 case Action::AnalyzeJobClass:
1024 T = new tools::Clang(*this); break;
1025 default:
1026 assert(false && "Unsupported action for TCE target.");
1027 }
1028 }
1029 return *T;
1030}
1031
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001032/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1033
1034OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001035 : Generic_ELF(Host, Triple) {
Daniel Dunbaree788e72009-12-21 18:54:17 +00001036 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001037 getFilePaths().push_back("/usr/lib");
1038}
1039
1040Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
1041 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001042 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001043 Key = Action::AnalyzeJobClass;
1044 else
1045 Key = JA.getKind();
1046
Rafael Espindoladda5b922010-11-07 23:13:01 +00001047 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1048 options::OPT_no_integrated_as,
1049 IsIntegratedAssemblerDefault());
1050
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001051 Tool *&T = Tools[Key];
1052 if (!T) {
1053 switch (Key) {
Rafael Espindoladda5b922010-11-07 23:13:01 +00001054 case Action::AssembleJobClass: {
1055 if (UseIntegratedAs)
1056 T = new tools::ClangAs(*this);
1057 else
1058 T = new tools::openbsd::Assemble(*this);
1059 break;
1060 }
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001061 case Action::LinkJobClass:
1062 T = new tools::openbsd::Link(*this); break;
1063 default:
1064 T = &Generic_GCC::SelectTool(C, JA);
1065 }
1066 }
1067
1068 return *T;
1069}
1070
Daniel Dunbar75358d22009-03-30 21:06:03 +00001071/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1072
Daniel Dunbar214afe92010-08-02 05:43:59 +00001073FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001074 : Generic_ELF(Host, Triple) {
Daniel Dunbar214afe92010-08-02 05:43:59 +00001075
1076 // Determine if we are compiling 32-bit code on an x86_64 platform.
1077 bool Lib32 = false;
1078 if (Triple.getArch() == llvm::Triple::x86 &&
1079 llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1080 llvm::Triple::x86_64)
1081 Lib32 = true;
1082
Daniel Dunbar7fb2c252010-06-15 15:03:31 +00001083 getProgramPaths().push_back(getDriver().Dir + "/../libexec");
1084 getProgramPaths().push_back("/usr/libexec");
Daniel Dunbarbc534662009-04-02 18:30:04 +00001085 if (Lib32) {
Daniel Dunbaree788e72009-12-21 18:54:17 +00001086 getFilePaths().push_back(getDriver().Dir + "/../lib32");
Daniel Dunbarbc534662009-04-02 18:30:04 +00001087 getFilePaths().push_back("/usr/lib32");
1088 } else {
Daniel Dunbaree788e72009-12-21 18:54:17 +00001089 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbarbc534662009-04-02 18:30:04 +00001090 getFilePaths().push_back("/usr/lib");
1091 }
Daniel Dunbar75358d22009-03-30 21:06:03 +00001092}
1093
1094Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
1095 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001096 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar75358d22009-03-30 21:06:03 +00001097 Key = Action::AnalyzeJobClass;
1098 else
1099 Key = JA.getKind();
1100
1101 Tool *&T = Tools[Key];
1102 if (!T) {
1103 switch (Key) {
Daniel Dunbar68a31d42009-03-31 17:45:15 +00001104 case Action::AssembleJobClass:
1105 T = new tools::freebsd::Assemble(*this); break;
Daniel Dunbar008f54a2009-04-01 19:36:32 +00001106 case Action::LinkJobClass:
1107 T = new tools::freebsd::Link(*this); break;
Daniel Dunbar75358d22009-03-30 21:06:03 +00001108 default:
1109 T = &Generic_GCC::SelectTool(C, JA);
1110 }
1111 }
1112
1113 return *T;
1114}
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001115
Chris Lattner38e317d2010-07-07 16:01:42 +00001116/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1117
1118Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple)
1119 : Generic_GCC(Host, Triple) {
1120 getFilePaths().push_back(getDriver().Dir + "/../lib");
1121 getFilePaths().push_back("/usr/lib");
1122 getFilePaths().push_back("/usr/gnu/lib");
1123 getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
1124}
1125
1126Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA) const {
1127 Action::ActionClass Key;
1128 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1129 Key = Action::AnalyzeJobClass;
1130 else
1131 Key = JA.getKind();
1132
1133 Tool *&T = Tools[Key];
1134 if (!T) {
1135 switch (Key) {
1136 case Action::AssembleJobClass:
1137 T = new tools::minix::Assemble(*this); break;
1138 case Action::LinkJobClass:
1139 T = new tools::minix::Link(*this); break;
1140 default:
1141 T = &Generic_GCC::SelectTool(C, JA);
1142 }
1143 }
1144
1145 return *T;
1146}
1147
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001148/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1149
1150AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
1151 : Generic_GCC(Host, Triple) {
1152
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001153 getProgramPaths().push_back(getDriver().getInstalledDir());
1154 if (getDriver().getInstalledDir() != getDriver().Dir.c_str())
1155 getProgramPaths().push_back(getDriver().Dir);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001156
Daniel Dunbaree788e72009-12-21 18:54:17 +00001157 getFilePaths().push_back(getDriver().Dir + "/../lib");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001158 getFilePaths().push_back("/usr/lib");
1159 getFilePaths().push_back("/usr/sfw/lib");
1160 getFilePaths().push_back("/opt/gcc4/lib");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00001161 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001162
1163}
1164
1165Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA) const {
1166 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001167 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001168 Key = Action::AnalyzeJobClass;
1169 else
1170 Key = JA.getKind();
1171
1172 Tool *&T = Tools[Key];
1173 if (!T) {
1174 switch (Key) {
1175 case Action::AssembleJobClass:
1176 T = new tools::auroraux::Assemble(*this); break;
1177 case Action::LinkJobClass:
1178 T = new tools::auroraux::Link(*this); break;
1179 default:
1180 T = &Generic_GCC::SelectTool(C, JA);
1181 }
1182 }
1183
1184 return *T;
1185}
1186
1187
Eli Friedman6b3454a2009-05-26 07:52:18 +00001188/// Linux toolchain (very bare-bones at the moment).
1189
Rafael Espindolac1da9812010-11-07 20:14:31 +00001190enum LinuxDistro {
1191 DebianLenny,
1192 DebianSqueeze,
1193 Fedora13,
1194 Fedora14,
1195 OpenSuse11_3,
1196 UbuntuLucid,
1197 UbuntuMaverick,
1198 UnknownDistro
1199};
1200
1201static bool IsFedora(enum LinuxDistro Distro) {
1202 return Distro == Fedora13 || Distro == Fedora14;
1203}
1204
1205static bool IsOpenSuse(enum LinuxDistro Distro) {
1206 return Distro == OpenSuse11_3;
1207}
1208
1209static bool IsDebian(enum LinuxDistro Distro) {
1210 return Distro == DebianLenny || Distro == DebianSqueeze;
1211}
1212
1213static bool IsUbuntu(enum LinuxDistro Distro) {
1214 return Distro == UbuntuLucid || Distro == UbuntuMaverick;
1215}
1216
1217static bool IsDebianBased(enum LinuxDistro Distro) {
1218 return IsDebian(Distro) || IsUbuntu(Distro);
1219}
1220
1221static bool HasMultilib(llvm::Triple::ArchType Arch, enum LinuxDistro Distro) {
1222 if (Arch == llvm::Triple::x86_64)
1223 return true;
1224 if (Arch == llvm::Triple::x86 && IsDebianBased(Distro))
1225 return true;
1226 return false;
1227}
1228
1229static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) {
1230 llvm::OwningPtr<const llvm::MemoryBuffer>
1231 LsbRelease(llvm::MemoryBuffer::getFile("/etc/lsb-release"));
1232 if (LsbRelease) {
1233 llvm::StringRef Data = LsbRelease.get()->getBuffer();
1234 llvm::SmallVector<llvm::StringRef, 8> Lines;
1235 Data.split(Lines, "\n");
1236 for (unsigned int i = 0, s = Lines.size(); i < s; ++ i) {
1237 if (Lines[i] == "DISTRIB_CODENAME=maverick")
1238 return UbuntuMaverick;
1239 else if (Lines[i] == "DISTRIB_CODENAME=lucid")
1240 return UbuntuLucid;
1241 }
1242 return UnknownDistro;
1243 }
1244
1245 llvm::OwningPtr<const llvm::MemoryBuffer>
1246 RHRelease(llvm::MemoryBuffer::getFile("/etc/redhat-release"));
1247 if (RHRelease) {
1248 llvm::StringRef Data = RHRelease.get()->getBuffer();
1249 if (Data.startswith("Fedora release 14 (Laughlin)"))
1250 return Fedora14;
1251 else if (Data.startswith("Fedora release 13 (Goddard)"))
1252 return Fedora13;
1253 return UnknownDistro;
1254 }
1255
1256 llvm::OwningPtr<const llvm::MemoryBuffer>
1257 DebianVersion(llvm::MemoryBuffer::getFile("/etc/debian_version"));
1258 if (DebianVersion) {
1259 llvm::StringRef Data = DebianVersion.get()->getBuffer();
1260 if (Data[0] == '5')
1261 return DebianLenny;
1262 else if (Data.startswith("squeeze/sid"))
1263 return DebianSqueeze;
1264 return UnknownDistro;
1265 }
1266
1267 llvm::OwningPtr<const llvm::MemoryBuffer>
1268 SuseRelease(llvm::MemoryBuffer::getFile("/etc/SuSE-release"));
1269 if (SuseRelease) {
1270 llvm::StringRef Data = SuseRelease.get()->getBuffer();
1271 if (Data.startswith("openSUSE 11.3"))
1272 return OpenSuse11_3;
1273 return UnknownDistro;
1274 }
1275
1276 return UnknownDistro;
1277}
1278
Eli Friedman6b3454a2009-05-26 07:52:18 +00001279Linux::Linux(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001280 : Generic_ELF(Host, Triple) {
Rafael Espindolac1da9812010-11-07 20:14:31 +00001281 llvm::Triple::ArchType Arch =
1282 llvm::Triple(getDriver().DefaultHostTriple).getArch();
Daniel Dunbara9822de2009-08-06 01:47:11 +00001283
Rafael Espindolac1da9812010-11-07 20:14:31 +00001284 std::string Suffix32 = "";
1285 if (Arch == llvm::Triple::x86_64)
1286 Suffix32 = "/32";
Daniel Dunbara9822de2009-08-06 01:47:11 +00001287
Rafael Espindolac1da9812010-11-07 20:14:31 +00001288 std::string Suffix64 = "";
1289 if (Arch == llvm::Triple::x86)
1290 Suffix64 = "/64";
1291
1292 std::string Lib32 = "lib";
1293
1294 if ( llvm::sys::Path("/lib32").exists())
1295 Lib32 = "lib32";
1296
1297 std::string Lib64 = "lib";
1298 llvm::sys::Path Lib64Path("/lib64");
1299 if (Lib64Path.exists() && !Lib64Path.isSymLink())
1300 Lib64 = "lib64";
1301
1302 std::string GccTriple = "";
1303 if (Arch == llvm::Triple::arm) {
1304 if (llvm::sys::Path("/usr/lib/gcc/arm-linux-gnueabi").exists())
1305 GccTriple = "arm-linux-gnueabi";
1306 } else if (Arch == llvm::Triple::x86_64) {
1307 if (llvm::sys::Path("/usr/lib/gcc/x86_64-linux-gnu").exists())
1308 GccTriple = "x86_64-linux-gnu";
1309 else if (llvm::sys::Path("/usr/lib/gcc/x86_64-redhat-linux").exists())
1310 GccTriple = "x86_64-redhat-linux";
1311 else if (llvm::sys::Path("/usr/lib64/gcc/x86_64-suse-linux").exists())
1312 GccTriple = "x86_64-suse-linux";
1313 } else if (Arch == llvm::Triple::x86) {
1314 if (llvm::sys::Path("/usr/lib/gcc/i686-linux-gnu").exists())
1315 GccTriple = "i686-linux-gnu";
1316 else if (llvm::sys::Path("/usr/lib/gcc/i486-linux-gnu").exists())
1317 GccTriple = "i486-linux-gnu";
1318 else if (llvm::sys::Path("/usr/lib/gcc/i686-redhat-linux").exists())
1319 GccTriple = "i686-redhat-linux";
1320 else if (llvm::sys::Path("/usr/lib/gcc/i586-suse-linux").exists())
1321 GccTriple = "i586-suse-linux";
1322 }
1323
1324 const char* GccVersions[] = {"4.5.1", "4.5", "4.4.5", "4.4.4", "4.4.3",
1325 "4.3.2"};
1326 std::string Base = "";
1327 for (unsigned i = 0; i < sizeof(GccVersions)/sizeof(char*); ++i) {
1328 std::string Suffix = GccTriple + "/" + GccVersions[i];
1329 std::string t1 = "/usr/lib/gcc/" + Suffix;
1330 if (llvm::sys::Path(t1 + "/crtbegin.o").exists()) {
1331 Base = t1;
1332 break;
1333 }
1334 std::string t2 = "/usr/lib64/gcc/" + Suffix;
1335 if (llvm::sys::Path(t2 + "/crtbegin.o").exists()) {
1336 Base = t2;
1337 break;
1338 }
1339 }
1340
1341 path_list &Paths = getFilePaths();
1342 bool Is32Bits = getArch() == llvm::Triple::x86;
1343
1344 std::string Suffix;
1345 std::string Lib;
1346
1347 if (Is32Bits) {
1348 Suffix = Suffix32;
1349 Lib = Lib32;
1350 } else {
1351 Suffix = Suffix64;
1352 Lib = Lib64;
1353 }
1354
1355 llvm::sys::Path LinkerPath(Base + "/../../../../" + GccTriple + "/bin/ld");
1356 if (LinkerPath.exists())
1357 Linker = LinkerPath.str();
1358 else
1359 Linker = GetProgramPath("ld");
1360
1361 LinuxDistro Distro = DetectLinuxDistro(Arch);
1362
Rafael Espindola94c80222010-11-08 14:48:47 +00001363 if (IsUbuntu(Distro)) {
1364 ExtraOpts.push_back("-z");
1365 ExtraOpts.push_back("relro");
1366 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00001367
1368 if (Arch == llvm::Triple::arm)
1369 ExtraOpts.push_back("-X");
1370
1371 if (IsFedora(Distro) || Distro == UbuntuMaverick)
1372 ExtraOpts.push_back("--hash-style=gnu");
1373
1374 if (IsDebian(Distro) || Distro == UbuntuLucid)
1375 ExtraOpts.push_back("--hash-style=both");
1376
1377 if (IsFedora(Distro))
1378 ExtraOpts.push_back("--no-add-needed");
1379
1380 if (Distro == DebianSqueeze || IsUbuntu(Distro) || IsOpenSuse(Distro) ||
1381 IsFedora(Distro))
1382 ExtraOpts.push_back("--build-id");
1383
1384 Paths.push_back(Base + Suffix);
1385 if (HasMultilib(Arch, Distro)) {
1386 if (IsOpenSuse(Distro) && Is32Bits)
1387 Paths.push_back(Base + "/../../../../" + GccTriple + "/lib/../lib");
1388 Paths.push_back(Base + "/../../../../" + Lib);
1389 Paths.push_back("/lib/../" + Lib);
1390 Paths.push_back("/usr/lib/../" + Lib);
1391 }
1392 if (!Suffix.empty())
1393 Paths.push_back(Base);
1394 if (IsOpenSuse(Distro))
1395 Paths.push_back(Base + "/../../../../" + GccTriple + "/lib");
1396 Paths.push_back(Base + "/../../..");
1397 if (Arch == getArch() && IsUbuntu(Distro))
1398 Paths.push_back("/usr/lib/" + GccTriple);
1399}
1400
1401bool Linux::HasNativeLLVMSupport() const {
1402 return true;
Eli Friedman6b3454a2009-05-26 07:52:18 +00001403}
1404
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001405Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA) const {
1406 Action::ActionClass Key;
1407 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1408 Key = Action::AnalyzeJobClass;
1409 else
1410 Key = JA.getKind();
1411
Rafael Espindoladda5b922010-11-07 23:13:01 +00001412 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1413 options::OPT_no_integrated_as,
1414 IsIntegratedAssemblerDefault());
1415
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001416 Tool *&T = Tools[Key];
1417 if (!T) {
1418 switch (Key) {
1419 case Action::AssembleJobClass:
Rafael Espindoladda5b922010-11-07 23:13:01 +00001420 if (UseIntegratedAs)
1421 T = new tools::ClangAs(*this);
1422 else
1423 T = new tools::linuxtools::Assemble(*this);
1424 break;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001425 case Action::LinkJobClass:
1426 T = new tools::linuxtools::Link(*this); break;
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001427 default:
1428 T = &Generic_GCC::SelectTool(C, JA);
1429 }
1430 }
1431
1432 return *T;
1433}
1434
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001435/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
1436
Daniel Dunbarcb8ab232009-05-22 02:53:45 +00001437DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001438 : Generic_ELF(Host, Triple) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001439
1440 // Path mangling to find libexec
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001441 getProgramPaths().push_back(getDriver().getInstalledDir());
1442 if (getDriver().getInstalledDir() != getDriver().Dir.c_str())
1443 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001444
Daniel Dunbaree788e72009-12-21 18:54:17 +00001445 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001446 getFilePaths().push_back("/usr/lib");
1447 getFilePaths().push_back("/usr/lib/gcc41");
1448}
1449
1450Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA) const {
1451 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001452 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001453 Key = Action::AnalyzeJobClass;
1454 else
1455 Key = JA.getKind();
1456
1457 Tool *&T = Tools[Key];
1458 if (!T) {
1459 switch (Key) {
1460 case Action::AssembleJobClass:
1461 T = new tools::dragonfly::Assemble(*this); break;
1462 case Action::LinkJobClass:
1463 T = new tools::dragonfly::Link(*this); break;
1464 default:
1465 T = &Generic_GCC::SelectTool(C, JA);
1466 }
1467 }
1468
1469 return *T;
1470}
Michael J. Spencerff58e362010-08-21 21:55:07 +00001471
1472Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple)
1473 : ToolChain(Host, Triple) {
1474}
1475
1476Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA) const {
1477 Action::ActionClass Key;
1478 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1479 Key = Action::AnalyzeJobClass;
1480 else
1481 Key = JA.getKind();
1482
1483 Tool *&T = Tools[Key];
1484 if (!T) {
1485 switch (Key) {
1486 case Action::InputClass:
1487 case Action::BindArchClass:
Chandler Carruthe97673f2010-08-22 06:56:37 +00001488 case Action::LipoJobClass:
1489 case Action::DsymutilJobClass:
Michael J. Spencerff58e362010-08-21 21:55:07 +00001490 assert(0 && "Invalid tool kind.");
1491 case Action::PreprocessJobClass:
1492 case Action::PrecompileJobClass:
1493 case Action::AnalyzeJobClass:
1494 case Action::CompileJobClass:
1495 T = new tools::Clang(*this); break;
1496 case Action::AssembleJobClass:
1497 T = new tools::ClangAs(*this); break;
1498 case Action::LinkJobClass:
1499 T = new tools::visualstudio::Link(*this); break;
1500 }
1501 }
1502
1503 return *T;
1504}
1505
1506bool Windows::IsIntegratedAssemblerDefault() const {
1507 return true;
1508}
1509
1510bool Windows::IsUnwindTablesDefault() const {
1511 // FIXME: Gross; we should probably have some separate target
1512 // definition, possibly even reusing the one in clang.
1513 return getArchName() == "x86_64";
1514}
1515
1516const char *Windows::GetDefaultRelocationModel() const {
1517 return "static";
1518}
1519
1520const char *Windows::GetForcedPicModel() const {
1521 if (getArchName() == "x86_64")
1522 return "pic";
1523 return 0;
1524}