blob: d5b132c7251c6c6ea299c4d2e7a099b88b9c0df8 [file] [log] [blame]
Nick Lewycky3fdcc6f2010-12-31 17:31:54 +00001//===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
Daniel Dunbar39176082009-03-20 00:20:03 +00002//
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
Rafael Espindola14ea13c2011-06-02 22:18:46 +000012#ifdef HAVE_CLANG_CONFIG_H
13# include "clang/Config/config.h"
14#endif
15
Daniel Dunbarf3cad362009-03-25 04:13:45 +000016#include "clang/Driver/Arg.h"
17#include "clang/Driver/ArgList.h"
Daniel Dunbar0f602de2010-05-20 21:48:38 +000018#include "clang/Driver/Compilation.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000019#include "clang/Driver/Driver.h"
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +000020#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000021#include "clang/Driver/HostInfo.h"
John McCall9f084a32011-07-06 00:26:06 +000022#include "clang/Driver/ObjCRuntime.h"
Daniel Dunbar27e738d2009-11-19 00:15:11 +000023#include "clang/Driver/OptTable.h"
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +000024#include "clang/Driver/Option.h"
Daniel Dunbar265e9ef2009-11-19 04:25:22 +000025#include "clang/Driver/Options.h"
Douglas Gregor34916db2010-09-03 17:16:03 +000026#include "clang/Basic/Version.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000027
Daniel Dunbar00577ad2010-08-23 22:35:37 +000028#include "llvm/ADT/SmallString.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000029#include "llvm/ADT/StringExtras.h"
John McCallf85e1932011-06-15 23:02:42 +000030#include "llvm/ADT/STLExtras.h"
Daniel Dunbar84ec96c2009-09-09 22:33:15 +000031#include "llvm/Support/ErrorHandling.h"
Michael J. Spencer32bef4e2011-01-10 02:34:13 +000032#include "llvm/Support/FileSystem.h"
Rafael Espindolac1da9812010-11-07 20:14:31 +000033#include "llvm/Support/MemoryBuffer.h"
Daniel Dunbarec069ed2009-03-25 06:58:31 +000034#include "llvm/Support/raw_ostream.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000035#include "llvm/Support/Path.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000036#include "llvm/Support/system_error.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000037
Daniel Dunbarf36a06a2009-04-10 21:00:07 +000038#include <cstdlib> // ::getenv
39
Dylan Noblesmith89bb6142011-06-23 13:50:47 +000040#include "llvm/Config/config.h" // for CXX_INCLUDE_ROOT
41
Daniel Dunbar39176082009-03-20 00:20:03 +000042using namespace clang::driver;
43using namespace clang::driver::toolchains;
Chris Lattner5f9e2722011-07-23 10:55:15 +000044using namespace clang;
Daniel Dunbar39176082009-03-20 00:20:03 +000045
Daniel Dunbarf3955282009-09-04 18:34:51 +000046/// Darwin - Darwin tool chain for i386 and x86_64.
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +000047
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000048Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple)
John McCallf85e1932011-06-15 23:02:42 +000049 : ToolChain(Host, Triple), TargetInitialized(false),
50 ARCRuntimeForSimulator(ARCSimulator_None)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +000051{
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000052 // Compute the initial Darwin version based on the host.
53 bool HadExtra;
54 std::string OSName = Triple.getOSName();
Daniel Dunbar34f9e292011-02-25 21:20:15 +000055 if (!Driver::GetReleaseVersion(&OSName.c_str()[6],
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000056 DarwinVersion[0], DarwinVersion[1],
57 DarwinVersion[2], HadExtra))
Chris Lattner5f9e2722011-07-23 10:55:15 +000058 getDriver().Diag(diag::err_drv_invalid_darwin_version) << OSName;
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000059
Daniel Dunbar02633b52009-03-26 16:23:12 +000060 llvm::raw_string_ostream(MacosxVersionMin)
Daniel Dunbar25b58eb2010-08-02 05:44:07 +000061 << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.'
62 << DarwinVersion[1];
Daniel Dunbar1d4612b2009-09-18 08:15:13 +000063}
64
Daniel Dunbar41800112010-08-02 05:43:56 +000065types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
66 types::ID Ty = types::lookupTypeForExtension(Ext);
67
68 // Darwin always preprocesses assembly files (unless -x is used explicitly).
69 if (Ty == types::TY_PP_Asm)
70 return types::TY_Asm;
71
72 return Ty;
73}
74
Daniel Dunbarb993f5d2010-09-17 00:24:52 +000075bool Darwin::HasNativeLLVMSupport() const {
76 return true;
77}
78
John McCall9f084a32011-07-06 00:26:06 +000079bool Darwin::hasARCRuntime() const {
John McCallf85e1932011-06-15 23:02:42 +000080 // FIXME: Remove this once there is a proper way to detect an ARC runtime
81 // for the simulator.
82 switch (ARCRuntimeForSimulator) {
83 case ARCSimulator_None:
84 break;
85 case ARCSimulator_HasARCRuntime:
86 return true;
87 case ARCSimulator_NoARCRuntime:
88 return false;
89 }
90
91 if (isTargetIPhoneOS())
92 return !isIPhoneOSVersionLT(5);
93 else
94 return !isMacosxVersionLT(10, 7);
95}
96
John McCall9f084a32011-07-06 00:26:06 +000097/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
98void Darwin::configureObjCRuntime(ObjCRuntime &runtime) const {
99 if (runtime.getKind() != ObjCRuntime::NeXT)
100 return ToolChain::configureObjCRuntime(runtime);
101
102 runtime.HasARC = runtime.HasWeak = hasARCRuntime();
John McCall256a76e2011-07-06 01:22:26 +0000103
104 // So far, objc_terminate is only available in iOS 5.
105 // FIXME: do the simulator logic properly.
106 if (!ARCRuntimeForSimulator && isTargetIPhoneOS())
107 runtime.HasTerminate = !isIPhoneOSVersionLT(5);
108 else
109 runtime.HasTerminate = false;
John McCall9f084a32011-07-06 00:26:06 +0000110}
111
Daniel Dunbareeff4062010-01-22 02:04:58 +0000112// FIXME: Can we tablegen this?
Chris Lattner5f9e2722011-07-23 10:55:15 +0000113static const char *GetArmArchForMArch(StringRef Value) {
Daniel Dunbareeff4062010-01-22 02:04:58 +0000114 if (Value == "armv6k")
115 return "armv6";
116
117 if (Value == "armv5tej")
118 return "armv5";
119
120 if (Value == "xscale")
121 return "xscale";
122
123 if (Value == "armv4t")
124 return "armv4t";
125
126 if (Value == "armv7" || Value == "armv7-a" || Value == "armv7-r" ||
127 Value == "armv7-m" || Value == "armv7a" || Value == "armv7r" ||
128 Value == "armv7m")
129 return "armv7";
130
131 return 0;
132}
133
134// FIXME: Can we tablegen this?
Chris Lattner5f9e2722011-07-23 10:55:15 +0000135static const char *GetArmArchForMCpu(StringRef Value) {
Daniel Dunbareeff4062010-01-22 02:04:58 +0000136 if (Value == "arm10tdmi" || Value == "arm1020t" || Value == "arm9e" ||
137 Value == "arm946e-s" || Value == "arm966e-s" ||
138 Value == "arm968e-s" || Value == "arm10e" ||
139 Value == "arm1020e" || Value == "arm1022e" || Value == "arm926ej-s" ||
140 Value == "arm1026ej-s")
141 return "armv5";
142
143 if (Value == "xscale")
144 return "xscale";
145
146 if (Value == "arm1136j-s" || Value == "arm1136jf-s" ||
Bob Wilson1ec0ade2011-03-21 20:40:05 +0000147 Value == "arm1176jz-s" || Value == "arm1176jzf-s" ||
148 Value == "cortex-m0" )
Daniel Dunbareeff4062010-01-22 02:04:58 +0000149 return "armv6";
150
151 if (Value == "cortex-a8" || Value == "cortex-r4" || Value == "cortex-m3")
152 return "armv7";
153
154 return 0;
155}
156
Chris Lattner5f9e2722011-07-23 10:55:15 +0000157StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
Daniel Dunbareeff4062010-01-22 02:04:58 +0000158 switch (getTriple().getArch()) {
159 default:
160 return getArchName();
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000161
Douglas Gregorf0594d82011-03-06 19:11:49 +0000162 case llvm::Triple::thumb:
Daniel Dunbareeff4062010-01-22 02:04:58 +0000163 case llvm::Triple::arm: {
164 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
165 if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
166 return Arch;
167
168 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
169 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
170 return Arch;
171
172 return "arm";
173 }
174 }
175}
176
Daniel Dunbarf3955282009-09-04 18:34:51 +0000177Darwin::~Darwin() {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000178 // Free tool implementations.
179 for (llvm::DenseMap<unsigned, Tool*>::iterator
180 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
181 delete it->second;
182}
183
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000184std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args) const {
185 llvm::Triple Triple(ComputeLLVMTriple(Args));
186
187 // If the target isn't initialized (e.g., an unknown Darwin platform, return
188 // the default triple).
189 if (!isTargetInitialized())
190 return Triple.getTriple();
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000191
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000192 unsigned Version[3];
193 getTargetVersion(Version);
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000194
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000195 llvm::SmallString<16> Str;
Daniel Dunbar729f38e2011-04-19 21:45:47 +0000196 llvm::raw_svector_ostream(Str)
Daniel Dunbar659d23a2011-04-19 23:34:17 +0000197 << (isTargetIPhoneOS() ? "ios" : "macosx")
Daniel Dunbar729f38e2011-04-19 21:45:47 +0000198 << Version[0] << "." << Version[1] << "." << Version[2];
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000199 Triple.setOSName(Str.str());
200
201 return Triple.getTriple();
202}
203
Daniel Dunbarac0659a2011-03-18 20:14:00 +0000204Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA,
205 const ActionList &Inputs) const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000206 Action::ActionClass Key;
Daniel Dunbar5ce872f2011-03-18 20:14:03 +0000207
208 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) {
209 // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI.
210 if (Inputs.size() == 1 &&
211 types::isCXX(Inputs[0]->getType()) &&
212 getTriple().getOS() == llvm::Triple::Darwin &&
213 getTriple().getArch() == llvm::Triple::x86 &&
Bob Wilsona544aee2011-08-13 23:48:55 +0000214 (C.getArgs().getLastArg(options::OPT_fapple_kext) ||
215 C.getArgs().getLastArg(options::OPT_mkernel)))
Daniel Dunbar5ce872f2011-03-18 20:14:03 +0000216 Key = JA.getKind();
217 else
218 Key = Action::AnalyzeJobClass;
219 } else
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000220 Key = JA.getKind();
221
Daniel Dunbar0f602de2010-05-20 21:48:38 +0000222 // FIXME: This doesn't belong here, but ideally we will support static soon
223 // anyway.
224 bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
225 C.getArgs().hasArg(options::OPT_static) ||
226 C.getArgs().hasArg(options::OPT_fapple_kext));
227 bool IsIADefault = IsIntegratedAssemblerDefault() && !HasStatic;
228 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
229 options::OPT_no_integrated_as,
230 IsIADefault);
231
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000232 Tool *&T = Tools[Key];
233 if (!T) {
234 switch (Key) {
235 case Action::InputClass:
236 case Action::BindArchClass:
237 assert(0 && "Invalid tool kind.");
238 case Action::PreprocessJobClass:
Daniel Dunbar9120f172009-03-29 22:27:40 +0000239 T = new tools::darwin::Preprocess(*this); break;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000240 case Action::AnalyzeJobClass:
241 T = new tools::Clang(*this); break;
Daniel Dunbar9120f172009-03-29 22:27:40 +0000242 case Action::PrecompileJobClass:
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000243 case Action::CompileJobClass:
Daniel Dunbar9120f172009-03-29 22:27:40 +0000244 T = new tools::darwin::Compile(*this); break;
Daniel Dunbar0f602de2010-05-20 21:48:38 +0000245 case Action::AssembleJobClass: {
246 if (UseIntegratedAs)
247 T = new tools::ClangAs(*this);
248 else
249 T = new tools::darwin::Assemble(*this);
250 break;
251 }
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000252 case Action::LinkJobClass:
Daniel Dunbar8f289622009-09-04 17:39:02 +0000253 T = new tools::darwin::Link(*this); break;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000254 case Action::LipoJobClass:
255 T = new tools::darwin::Lipo(*this); break;
Daniel Dunbar6e0f2542010-06-04 18:28:36 +0000256 case Action::DsymutilJobClass:
257 T = new tools::darwin::Dsymutil(*this); break;
Eric Christopherf8571862011-08-23 17:56:55 +0000258 case Action::VerifyJobClass:
259 T = new tools::darwin::VerifyDebug(*this); break;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000260 }
261 }
262
263 return *T;
264}
265
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000266
Daniel Dunbar25b58eb2010-08-02 05:44:07 +0000267DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple)
268 : Darwin(Host, Triple)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000269{
Daniel Dunbar47023092011-03-18 19:25:15 +0000270 std::string UsrPrefix = "llvm-gcc-4.2/";
271
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000272 getProgramPaths().push_back(getDriver().getInstalledDir());
273 if (getDriver().getInstalledDir() != getDriver().Dir)
274 getProgramPaths().push_back(getDriver().Dir);
275
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000276 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000277 getProgramPaths().push_back(getDriver().getInstalledDir());
278 if (getDriver().getInstalledDir() != getDriver().Dir)
279 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000280
281 // For fallback, we need to know how to find the GCC cc1 executables, so we
Daniel Dunbar47023092011-03-18 19:25:15 +0000282 // also add the GCC libexec paths. This is legacy code that can be removed
283 // once fallback is no longer useful.
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000284 std::string ToolChainDir = "i686-apple-darwin";
285 ToolChainDir += llvm::utostr(DarwinVersion[0]);
286 ToolChainDir += "/4.2.1";
287
288 std::string Path = getDriver().Dir;
Daniel Dunbar47023092011-03-18 19:25:15 +0000289 Path += "/../" + UsrPrefix + "libexec/gcc/";
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000290 Path += ToolChainDir;
291 getProgramPaths().push_back(Path);
292
Daniel Dunbar47023092011-03-18 19:25:15 +0000293 Path = "/usr/" + UsrPrefix + "libexec/gcc/";
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000294 Path += ToolChainDir;
295 getProgramPaths().push_back(Path);
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000296}
297
298void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
299 ArgStringList &CmdArgs) const {
300 // The Clang toolchain uses explicit paths for internal libraries.
Daniel Dunbar424b6612010-06-30 23:56:13 +0000301
302 // Unfortunately, we still might depend on a few of the libraries that are
303 // only available in the gcc library directory (in particular
304 // libstdc++.dylib). For now, hardcode the path to the known install location.
305 llvm::sys::Path P(getDriver().Dir);
306 P.eraseComponent(); // .../usr/bin -> ../usr
307 P.appendComponent("lib");
308 P.appendComponent("gcc");
309 switch (getTriple().getArch()) {
310 default:
311 assert(0 && "Invalid Darwin arch!");
312 case llvm::Triple::x86:
313 case llvm::Triple::x86_64:
314 P.appendComponent("i686-apple-darwin10");
315 break;
316 case llvm::Triple::arm:
317 case llvm::Triple::thumb:
318 P.appendComponent("arm-apple-darwin10");
319 break;
320 case llvm::Triple::ppc:
321 case llvm::Triple::ppc64:
322 P.appendComponent("powerpc-apple-darwin10");
323 break;
324 }
325 P.appendComponent("4.2.1");
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000326
327 // Determine the arch specific GCC subdirectory.
328 const char *ArchSpecificDir = 0;
329 switch (getTriple().getArch()) {
330 default:
331 break;
332 case llvm::Triple::arm:
Daniel Dunbar3a0e3922010-08-26 00:55:52 +0000333 case llvm::Triple::thumb: {
334 std::string Triple = ComputeLLVMTriple(Args);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000335 StringRef TripleStr = Triple;
Daniel Dunbar3a0e3922010-08-26 00:55:52 +0000336 if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5"))
337 ArchSpecificDir = "v5";
338 else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6"))
339 ArchSpecificDir = "v6";
340 else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7"))
341 ArchSpecificDir = "v7";
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000342 break;
Daniel Dunbar3a0e3922010-08-26 00:55:52 +0000343 }
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000344 case llvm::Triple::ppc64:
345 ArchSpecificDir = "ppc64";
346 break;
347 case llvm::Triple::x86_64:
348 ArchSpecificDir = "x86_64";
349 break;
350 }
351
352 if (ArchSpecificDir) {
353 P.appendComponent(ArchSpecificDir);
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000354 bool Exists;
355 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Daniel Dunbareab3bc42010-08-23 20:58:52 +0000356 CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
357 P.eraseComponent();
358 }
359
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000360 bool Exists;
361 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Daniel Dunbar424b6612010-06-30 23:56:13 +0000362 CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000363}
364
John McCallf85e1932011-06-15 23:02:42 +0000365void DarwinClang::AddLinkARCArgs(const ArgList &Args,
366 ArgStringList &CmdArgs) const {
Eric Christopherf8571862011-08-23 17:56:55 +0000367
368 CmdArgs.push_back("-force_load");
John McCallf85e1932011-06-15 23:02:42 +0000369 llvm::sys::Path P(getDriver().ClangExecutable);
370 P.eraseComponent(); // 'clang'
371 P.eraseComponent(); // 'bin'
372 P.appendComponent("lib");
373 P.appendComponent("arc");
374 P.appendComponent("libarclite_");
375 std::string s = P.str();
376 // Mash in the platform.
377 if (isTargetIPhoneOS())
378 s += "iphoneos";
379 // FIXME: isTargetIphoneOSSimulator() is not returning true.
380 else if (ARCRuntimeForSimulator != ARCSimulator_None)
381 s += "iphonesimulator";
382 else
383 s += "macosx";
384 s += ".a";
385
386 CmdArgs.push_back(Args.MakeArgString(s));
387}
388
Eric Christopher3404fe72011-06-22 17:41:40 +0000389void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
Eric Christopherf8571862011-08-23 17:56:55 +0000390 ArgStringList &CmdArgs,
Eric Christopher3404fe72011-06-22 17:41:40 +0000391 const char *DarwinStaticLib) const {
392 llvm::sys::Path P(getDriver().ResourceDir);
393 P.appendComponent("lib");
394 P.appendComponent("darwin");
395 P.appendComponent(DarwinStaticLib);
Eric Christopherf8571862011-08-23 17:56:55 +0000396
Eric Christopher3404fe72011-06-22 17:41:40 +0000397 // For now, allow missing resource libraries to support developers who may
398 // not have compiler-rt checked out or integrated into their build.
399 bool Exists;
400 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
401 CmdArgs.push_back(Args.MakeArgString(P.str()));
402}
403
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000404void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
405 ArgStringList &CmdArgs) const {
Daniel Dunbareec99102010-01-22 03:38:14 +0000406 // Darwin doesn't support real static executables, don't link any runtime
407 // libraries with -static.
408 if (Args.hasArg(options::OPT_static))
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000409 return;
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000410
411 // Reject -static-libgcc for now, we can deal with this when and if someone
412 // cares. This is useful in situations where someone wants to statically link
413 // something like libstdc++, and needs its runtime support routines.
414 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000415 getDriver().Diag(diag::err_drv_unsupported_opt)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000416 << A->getAsString(Args);
417 return;
418 }
419
Daniel Dunbareec99102010-01-22 03:38:14 +0000420 // Otherwise link libSystem, then the dynamic runtime library, and finally any
421 // target specific static runtime library.
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000422 CmdArgs.push_back("-lSystem");
Daniel Dunbareec99102010-01-22 03:38:14 +0000423
424 // Select the dynamic runtime library and the target specific static library.
Daniel Dunbar251ca6c2010-01-27 00:56:37 +0000425 if (isTargetIPhoneOS()) {
Daniel Dunbar87e945f2011-04-30 04:25:16 +0000426 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
427 // it never went into the SDK.
428 if (!isTargetIOSSimulator())
429 CmdArgs.push_back("-lgcc_s.1");
Daniel Dunbareec99102010-01-22 03:38:14 +0000430
Daniel Dunbar3cceec52011-04-18 23:48:36 +0000431 // We currently always need a static runtime library for iOS.
Eric Christopher3404fe72011-06-22 17:41:40 +0000432 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
Daniel Dunbareec99102010-01-22 03:38:14 +0000433 } else {
Daniel Dunbareec99102010-01-22 03:38:14 +0000434 // The dynamic runtime library was merged with libSystem for 10.6 and
435 // beyond; only 10.4 and 10.5 need an additional runtime library.
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000436 if (isMacosxVersionLT(10, 5))
Daniel Dunbareec99102010-01-22 03:38:14 +0000437 CmdArgs.push_back("-lgcc_s.10.4");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000438 else if (isMacosxVersionLT(10, 6))
Daniel Dunbareec99102010-01-22 03:38:14 +0000439 CmdArgs.push_back("-lgcc_s.10.5");
440
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000441 // For OS X, we thought we would only need a static runtime library when
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000442 // targeting 10.4, to provide versions of the static functions which were
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000443 // omitted from 10.4.dylib.
444 //
445 // Unfortunately, that turned out to not be true, because Darwin system
446 // headers can still use eprintf on i386, and it is not exported from
447 // libSystem. Therefore, we still must provide a runtime library just for
448 // the tiny tiny handful of projects that *might* use that symbol.
449 if (isMacosxVersionLT(10, 5)) {
Eric Christopher3404fe72011-06-22 17:41:40 +0000450 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000451 } else {
452 if (getTriple().getArch() == llvm::Triple::x86)
Eric Christopher3404fe72011-06-22 17:41:40 +0000453 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
454 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000455 }
Daniel Dunbareec99102010-01-22 03:38:14 +0000456 }
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000457}
458
Chris Lattner5f9e2722011-07-23 10:55:15 +0000459static inline StringRef SimulatorVersionDefineName() {
John McCallf85e1932011-06-15 23:02:42 +0000460 return "__IPHONE_OS_VERSION_MIN_REQUIRED";
461}
462
463/// \brief Parse the simulator version define:
464/// __IPHONE_OS_VERSION_MIN_REQUIRED=([0-9])([0-9][0-9])([0-9][0-9])
465// and return the grouped values as integers, e.g:
466// __IPHONE_OS_VERSION_MIN_REQUIRED=40201
467// will return Major=4, Minor=2, Micro=1.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000468static bool GetVersionFromSimulatorDefine(StringRef define,
John McCallf85e1932011-06-15 23:02:42 +0000469 unsigned &Major, unsigned &Minor,
470 unsigned &Micro) {
471 assert(define.startswith(SimulatorVersionDefineName()));
Chris Lattner5f9e2722011-07-23 10:55:15 +0000472 StringRef name, version;
John McCallf85e1932011-06-15 23:02:42 +0000473 llvm::tie(name, version) = define.split('=');
474 if (version.empty())
475 return false;
476 std::string verstr = version.str();
477 char *end;
478 unsigned num = (unsigned) strtol(verstr.c_str(), &end, 10);
479 if (*end != '\0')
480 return false;
481 Major = num / 10000;
482 num = num % 10000;
483 Minor = num / 100;
484 Micro = num % 100;
485 return true;
486}
487
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000488void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000489 const OptTable &Opts = getDriver().getOpts();
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000490
Daniel Dunbar26031372010-01-27 00:56:25 +0000491 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000492 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
493 Arg *iOSSimVersion = Args.getLastArg(
494 options::OPT_mios_simulator_version_min_EQ);
John McCallf85e1932011-06-15 23:02:42 +0000495
496 // FIXME: HACK! When compiling for the simulator we don't get a
497 // '-miphoneos-version-min' to help us know whether there is an ARC runtime
498 // or not; try to parse a __IPHONE_OS_VERSION_MIN_REQUIRED
499 // define passed in command-line.
500 if (!iOSVersion) {
501 for (arg_iterator it = Args.filtered_begin(options::OPT_D),
502 ie = Args.filtered_end(); it != ie; ++it) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000503 StringRef define = (*it)->getValue(Args);
John McCallf85e1932011-06-15 23:02:42 +0000504 if (define.startswith(SimulatorVersionDefineName())) {
NAKAMURA Takumi57c43a22011-08-14 00:37:22 +0000505 unsigned Major = 0, Minor = 0, Micro = 0;
John McCallf85e1932011-06-15 23:02:42 +0000506 if (GetVersionFromSimulatorDefine(define, Major, Minor, Micro) &&
507 Major < 10 && Minor < 100 && Micro < 100) {
508 ARCRuntimeForSimulator = Major < 5 ? ARCSimulator_NoARCRuntime
509 : ARCSimulator_HasARCRuntime;
510 }
511 break;
512 }
513 }
514 }
515
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000516 if (OSXVersion && (iOSVersion || iOSSimVersion)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000517 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarff8857a2009-04-10 20:11:50 +0000518 << OSXVersion->getAsString(Args)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000519 << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
520 iOSVersion = iOSSimVersion = 0;
521 } else if (iOSVersion && iOSSimVersion) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000522 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000523 << iOSVersion->getAsString(Args)
524 << iOSSimVersion->getAsString(Args);
525 iOSSimVersion = 0;
526 } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
Chad Rosiera4884972011-08-31 20:56:25 +0000527 // If no deployment target was specified on the command line, check for
Daniel Dunbar816bc312010-01-26 01:45:19 +0000528 // environment defines.
Chad Rosiera4884972011-08-31 20:56:25 +0000529 StringRef OSXTarget;
530 StringRef iOSTarget;
531 StringRef iOSSimTarget;
532 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
533 OSXTarget = env;
534 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
535 iOSTarget = env;
536 if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
537 iOSSimTarget = env;
Daniel Dunbarf36a06a2009-04-10 21:00:07 +0000538
Chad Rosiera4884972011-08-31 20:56:25 +0000539 // If no '-miphoneos-version-min' specified on the command line and
540 // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
541 // based on isysroot.
542 if (iOSTarget.empty()) {
543 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
544 StringRef first, second;
545 StringRef isysroot = A->getValue(Args);
546 llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
547 if (second != "")
548 iOSTarget = second.substr(0,3);
549 }
550 }
Daniel Dunbar816bc312010-01-26 01:45:19 +0000551
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000552 // Handle conflicting deployment targets
Daniel Dunbar39053672010-02-02 17:31:12 +0000553 //
554 // FIXME: Don't hardcode default here.
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000555
556 // Do not allow conflicts with the iOS simulator target.
Chad Rosiera4884972011-08-31 20:56:25 +0000557 if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000558 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000559 << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
Chad Rosiera4884972011-08-31 20:56:25 +0000560 << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000561 "IPHONEOS_DEPLOYMENT_TARGET");
562 }
563
564 // Allow conflicts among OSX and iOS for historical reasons, but choose the
565 // default platform.
Chad Rosiera4884972011-08-31 20:56:25 +0000566 if (!OSXTarget.empty() && !iOSTarget.empty()) {
Daniel Dunbar39053672010-02-02 17:31:12 +0000567 if (getTriple().getArch() == llvm::Triple::arm ||
568 getTriple().getArch() == llvm::Triple::thumb)
Chad Rosiera4884972011-08-31 20:56:25 +0000569 OSXTarget = "";
Daniel Dunbar39053672010-02-02 17:31:12 +0000570 else
Chad Rosiera4884972011-08-31 20:56:25 +0000571 iOSTarget = "";
Daniel Dunbar39053672010-02-02 17:31:12 +0000572 }
Daniel Dunbar1a3c1d92010-01-29 17:02:25 +0000573
Chad Rosiera4884972011-08-31 20:56:25 +0000574 if (!OSXTarget.empty()) {
Daniel Dunbar30392de2009-09-04 18:35:21 +0000575 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000576 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
577 Args.append(OSXVersion);
Chad Rosiera4884972011-08-31 20:56:25 +0000578 } else if (!iOSTarget.empty()) {
Daniel Dunbar30392de2009-09-04 18:35:21 +0000579 const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000580 iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
581 Args.append(iOSVersion);
Chad Rosiera4884972011-08-31 20:56:25 +0000582 } else if (!iOSSimTarget.empty()) {
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000583 const Option *O = Opts.getOption(
584 options::OPT_mios_simulator_version_min_EQ);
585 iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
586 Args.append(iOSSimVersion);
Daniel Dunbar816bc312010-01-26 01:45:19 +0000587 } else {
Daniel Dunbar2bb38d02010-07-15 16:18:06 +0000588 // Otherwise, assume we are targeting OS X.
589 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000590 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
591 Args.append(OSXVersion);
Daniel Dunbar30392de2009-09-04 18:35:21 +0000592 }
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000593 }
Mike Stump1eb44332009-09-09 15:08:12 +0000594
Daniel Dunbar3fd823b2011-04-30 04:20:40 +0000595 // Reject invalid architecture combinations.
596 if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
597 getTriple().getArch() != llvm::Triple::x86_64)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000598 getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
Daniel Dunbar3fd823b2011-04-30 04:20:40 +0000599 << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
600 }
601
Daniel Dunbar26031372010-01-27 00:56:25 +0000602 // Set the tool chain target information.
603 unsigned Major, Minor, Micro;
604 bool HadExtra;
605 if (OSXVersion) {
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000606 assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
Daniel Dunbar26031372010-01-27 00:56:25 +0000607 if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
608 Micro, HadExtra) || HadExtra ||
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000609 Major != 10 || Minor >= 100 || Micro >= 100)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000610 getDriver().Diag(diag::err_drv_invalid_version_number)
Daniel Dunbar26031372010-01-27 00:56:25 +0000611 << OSXVersion->getAsString(Args);
612 } else {
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000613 const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
614 assert(Version && "Unknown target platform!");
615 if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor,
Daniel Dunbar26031372010-01-27 00:56:25 +0000616 Micro, HadExtra) || HadExtra ||
617 Major >= 10 || Minor >= 100 || Micro >= 100)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000618 getDriver().Diag(diag::err_drv_invalid_version_number)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000619 << Version->getAsString(Args);
Daniel Dunbar26031372010-01-27 00:56:25 +0000620 }
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000621
Daniel Dunbar5f5c37b2011-04-30 04:18:16 +0000622 bool IsIOSSim = bool(iOSSimVersion);
623
624 // In GCC, the simulator historically was treated as being OS X in some
625 // contexts, like determining the link logic, despite generally being called
626 // with an iOS deployment target. For compatibility, we detect the
627 // simulator as iOS + x86, and treat it differently in a few contexts.
628 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
629 getTriple().getArch() == llvm::Triple::x86_64))
630 IsIOSSim = true;
631
632 setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
Daniel Dunbarc0e665e2010-07-19 17:11:33 +0000633}
634
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000635void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000636 ArgStringList &CmdArgs) const {
637 CXXStdlibType Type = GetCXXStdlibType(Args);
638
639 switch (Type) {
640 case ToolChain::CST_Libcxx:
641 CmdArgs.push_back("-lc++");
642 break;
643
644 case ToolChain::CST_Libstdcxx: {
645 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
646 // it was previously found in the gcc lib dir. However, for all the Darwin
647 // platforms we care about it was -lstdc++.6, so we search for that
648 // explicitly if we can't see an obvious -lstdc++ candidate.
649
650 // Check in the sysroot first.
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000651 bool Exists;
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000652 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
653 llvm::sys::Path P(A->getValue(Args));
654 P.appendComponent("usr");
655 P.appendComponent("lib");
656 P.appendComponent("libstdc++.dylib");
657
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000658 if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) {
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000659 P.eraseComponent();
660 P.appendComponent("libstdc++.6.dylib");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000661 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000662 CmdArgs.push_back(Args.MakeArgString(P.str()));
663 return;
664 }
665 }
666 }
667
668 // Otherwise, look in the root.
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000669 if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&&
670 (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000671 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
672 return;
673 }
674
675 // Otherwise, let the linker search.
676 CmdArgs.push_back("-lstdc++");
677 break;
678 }
679 }
680}
681
Shantonu Sen7433fed2010-09-17 18:39:08 +0000682void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
683 ArgStringList &CmdArgs) const {
684
685 // For Darwin platforms, use the compiler-rt-based support library
686 // instead of the gcc-provided one (which is also incidentally
687 // only present in the gcc lib dir, which makes it hard to find).
688
689 llvm::sys::Path P(getDriver().ResourceDir);
690 P.appendComponent("lib");
691 P.appendComponent("darwin");
692 P.appendComponent("libclang_rt.cc_kext.a");
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000693
Shantonu Sen7433fed2010-09-17 18:39:08 +0000694 // For now, allow missing resource libraries to support developers who may
695 // not have compiler-rt checked out or integrated into their build.
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000696 bool Exists;
697 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Shantonu Sen7433fed2010-09-17 18:39:08 +0000698 CmdArgs.push_back(Args.MakeArgString(P.str()));
699}
700
Daniel Dunbarc0e665e2010-07-19 17:11:33 +0000701DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
702 const char *BoundArch) const {
703 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
704 const OptTable &Opts = getDriver().getOpts();
705
706 // FIXME: We really want to get out of the tool chain level argument
707 // translation business, as it makes the driver functionality much
708 // more opaque. For now, we follow gcc closely solely for the
709 // purpose of easily achieving feature parity & testability. Once we
710 // have something that works, we should reevaluate each translation
711 // and try to push it down into tool specific logic.
Daniel Dunbar26031372010-01-27 00:56:25 +0000712
Daniel Dunbar279c1db2010-06-11 22:00:26 +0000713 for (ArgList::const_iterator it = Args.begin(),
714 ie = Args.end(); it != ie; ++it) {
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000715 Arg *A = *it;
716
717 if (A->getOption().matches(options::OPT_Xarch__)) {
Daniel Dunbar2a45fa72011-06-21 00:20:17 +0000718 // Skip this argument unless the architecture matches either the toolchain
719 // triple arch, or the arch being bound.
720 //
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000721 // FIXME: Canonicalize name.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000722 StringRef XarchArch = A->getValue(Args, 0);
Daniel Dunbar2a45fa72011-06-21 00:20:17 +0000723 if (!(XarchArch == getArchName() ||
724 (BoundArch && XarchArch == BoundArch)))
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000725 continue;
726
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000727 Arg *OriginalArg = A;
Daniel Dunbar0e100312010-06-14 21:23:08 +0000728 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
729 unsigned Prev = Index;
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000730 Arg *XarchArg = Opts.ParseOneArg(Args, Index);
Mike Stump1eb44332009-09-09 15:08:12 +0000731
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000732 // If the argument parsing failed or more than one argument was
733 // consumed, the -Xarch_ argument's parameter tried to consume
734 // extra arguments. Emit an error and ignore.
735 //
736 // We also want to disallow any options which would alter the
737 // driver behavior; that isn't going to work in our model. We
738 // use isDriverOption() as an approximation, although things
739 // like -O4 are going to slip through.
Daniel Dunbar0e02f6e2011-04-21 17:41:34 +0000740 if (!XarchArg || Index > Prev + 1) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000741 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
Daniel Dunbar7e9293b2011-04-21 17:32:21 +0000742 << A->getAsString(Args);
743 continue;
744 } else if (XarchArg->getOption().isDriverOption()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000745 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000746 << A->getAsString(Args);
747 continue;
748 }
749
Daniel Dunbar478edc22009-03-29 22:29:05 +0000750 XarchArg->setBaseArg(A);
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000751 A = XarchArg;
Daniel Dunbar0e100312010-06-14 21:23:08 +0000752
753 DAL->AddSynthesizedArg(A);
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000754
755 // Linker input arguments require custom handling. The problem is that we
756 // have already constructed the phase actions, so we can not treat them as
757 // "input arguments".
758 if (A->getOption().isLinkerInput()) {
759 // Convert the argument into individual Zlinker_input_args.
760 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
761 DAL->AddSeparateArg(OriginalArg,
762 Opts.getOption(options::OPT_Zlinker_input),
763 A->getValue(Args, i));
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000764
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000765 }
766 continue;
767 }
Mike Stump1eb44332009-09-09 15:08:12 +0000768 }
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000769
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000770 // Sob. These is strictly gcc compatible for the time being. Apple
771 // gcc translates options twice, which means that self-expanding
772 // options add duplicates.
Daniel Dunbar9e1f9822009-11-19 04:14:53 +0000773 switch ((options::ID) A->getOption().getID()) {
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000774 default:
775 DAL->append(A);
776 break;
777
778 case options::OPT_mkernel:
779 case options::OPT_fapple_kext:
780 DAL->append(A);
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000781 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000782 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000783
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000784 case options::OPT_dependency_file:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000785 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
786 A->getValue(Args));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000787 break;
788
789 case options::OPT_gfull:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000790 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
791 DAL->AddFlagArg(A,
792 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000793 break;
794
795 case options::OPT_gused:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000796 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
797 DAL->AddFlagArg(A,
798 Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000799 break;
800
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000801 case options::OPT_shared:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000802 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000803 break;
804
805 case options::OPT_fconstant_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000806 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000807 break;
808
809 case options::OPT_fno_constant_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000810 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000811 break;
812
813 case options::OPT_Wnonportable_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000814 DAL->AddFlagArg(A,
815 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000816 break;
817
818 case options::OPT_Wno_nonportable_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000819 DAL->AddFlagArg(A,
820 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000821 break;
822
823 case options::OPT_fpascal_strings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000824 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000825 break;
826
827 case options::OPT_fno_pascal_strings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000828 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000829 break;
830 }
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000831 }
832
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000833 if (getTriple().getArch() == llvm::Triple::x86 ||
834 getTriple().getArch() == llvm::Triple::x86_64)
Daniel Dunbare4bdae72009-11-19 04:00:53 +0000835 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000836 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000837
838 // Add the arch options based on the particular spelling of -arch, to match
839 // how the driver driver works.
840 if (BoundArch) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000841 StringRef Name = BoundArch;
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000842 const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
843 const Option *MArch = Opts.getOption(options::OPT_march_EQ);
844
845 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
846 // which defines the list of which architectures we accept.
847 if (Name == "ppc")
848 ;
849 else if (Name == "ppc601")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000850 DAL->AddJoinedArg(0, MCpu, "601");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000851 else if (Name == "ppc603")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000852 DAL->AddJoinedArg(0, MCpu, "603");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000853 else if (Name == "ppc604")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000854 DAL->AddJoinedArg(0, MCpu, "604");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000855 else if (Name == "ppc604e")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000856 DAL->AddJoinedArg(0, MCpu, "604e");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000857 else if (Name == "ppc750")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000858 DAL->AddJoinedArg(0, MCpu, "750");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000859 else if (Name == "ppc7400")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000860 DAL->AddJoinedArg(0, MCpu, "7400");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000861 else if (Name == "ppc7450")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000862 DAL->AddJoinedArg(0, MCpu, "7450");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000863 else if (Name == "ppc970")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000864 DAL->AddJoinedArg(0, MCpu, "970");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000865
866 else if (Name == "ppc64")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000867 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000868
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000869 else if (Name == "i386")
870 ;
871 else if (Name == "i486")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000872 DAL->AddJoinedArg(0, MArch, "i486");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000873 else if (Name == "i586")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000874 DAL->AddJoinedArg(0, MArch, "i586");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000875 else if (Name == "i686")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000876 DAL->AddJoinedArg(0, MArch, "i686");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000877 else if (Name == "pentium")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000878 DAL->AddJoinedArg(0, MArch, "pentium");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000879 else if (Name == "pentium2")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000880 DAL->AddJoinedArg(0, MArch, "pentium2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000881 else if (Name == "pentpro")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000882 DAL->AddJoinedArg(0, MArch, "pentiumpro");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000883 else if (Name == "pentIIm3")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000884 DAL->AddJoinedArg(0, MArch, "pentium2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000885
886 else if (Name == "x86_64")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000887 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000888
889 else if (Name == "arm")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000890 DAL->AddJoinedArg(0, MArch, "armv4t");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000891 else if (Name == "armv4t")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000892 DAL->AddJoinedArg(0, MArch, "armv4t");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000893 else if (Name == "armv5")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000894 DAL->AddJoinedArg(0, MArch, "armv5tej");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000895 else if (Name == "xscale")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000896 DAL->AddJoinedArg(0, MArch, "xscale");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000897 else if (Name == "armv6")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000898 DAL->AddJoinedArg(0, MArch, "armv6k");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000899 else if (Name == "armv7")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000900 DAL->AddJoinedArg(0, MArch, "armv7a");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000901
902 else
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +0000903 llvm_unreachable("invalid Darwin arch");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000904 }
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000905
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000906 // Add an explicit version min argument for the deployment target. We do this
907 // after argument translation because -Xarch_ arguments may add a version min
908 // argument.
909 AddDeploymentTarget(*DAL);
910
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000911 return DAL;
Mike Stump1eb44332009-09-09 15:08:12 +0000912}
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000913
Daniel Dunbarf3955282009-09-04 18:34:51 +0000914bool Darwin::IsUnwindTablesDefault() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000915 // FIXME: Gross; we should probably have some separate target
916 // definition, possibly even reusing the one in clang.
917 return getArchName() == "x86_64";
918}
919
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +0000920bool Darwin::UseDwarfDebugFlags() const {
921 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
922 return S[0] != '\0';
923 return false;
924}
925
Daniel Dunbarb2987d12010-02-10 18:49:11 +0000926bool Darwin::UseSjLjExceptions() const {
927 // Darwin uses SjLj exceptions on ARM.
928 return (getTriple().getArch() == llvm::Triple::arm ||
929 getTriple().getArch() == llvm::Triple::thumb);
930}
931
Daniel Dunbarf3955282009-09-04 18:34:51 +0000932const char *Darwin::GetDefaultRelocationModel() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000933 return "pic";
934}
935
Daniel Dunbarf3955282009-09-04 18:34:51 +0000936const char *Darwin::GetForcedPicModel() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000937 if (getArchName() == "x86_64")
938 return "pic";
939 return 0;
940}
941
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +0000942bool Darwin::SupportsProfiling() const {
943 // Profiling instrumentation is only supported on x86.
944 return getArchName() == "i386" || getArchName() == "x86_64";
945}
946
Daniel Dunbar43a9b322010-04-10 16:20:23 +0000947bool Darwin::SupportsObjCGC() const {
948 // Garbage collection is supported everywhere except on iPhone OS.
949 return !isTargetIPhoneOS();
950}
951
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000952std::string
953Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args) const {
954 return ComputeLLVMTriple(Args);
955}
956
Daniel Dunbar39176082009-03-20 00:20:03 +0000957/// Generic_GCC - A tool chain using the 'gcc' command to perform
958/// all subcommands; this relies on gcc translating the majority of
959/// command line options.
960
Daniel Dunbarcb8ab232009-05-22 02:53:45 +0000961Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
Mike Stump1eb44332009-09-09 15:08:12 +0000962 : ToolChain(Host, Triple) {
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000963 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer86643b82011-03-01 22:50:47 +0000964 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000965 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbarc50b00d2009-03-23 16:15:50 +0000966}
967
Daniel Dunbar39176082009-03-20 00:20:03 +0000968Generic_GCC::~Generic_GCC() {
969 // Free tool implementations.
970 for (llvm::DenseMap<unsigned, Tool*>::iterator
971 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
972 delete it->second;
973}
974
Mike Stump1eb44332009-09-09 15:08:12 +0000975Tool &Generic_GCC::SelectTool(const Compilation &C,
Daniel Dunbarac0659a2011-03-18 20:14:00 +0000976 const JobAction &JA,
977 const ActionList &Inputs) const {
Daniel Dunbar39176082009-03-20 00:20:03 +0000978 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +0000979 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar39176082009-03-20 00:20:03 +0000980 Key = Action::AnalyzeJobClass;
981 else
982 Key = JA.getKind();
983
984 Tool *&T = Tools[Key];
985 if (!T) {
986 switch (Key) {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000987 case Action::InputClass:
988 case Action::BindArchClass:
Daniel Dunbar39176082009-03-20 00:20:03 +0000989 assert(0 && "Invalid tool kind.");
990 case Action::PreprocessJobClass:
991 T = new tools::gcc::Preprocess(*this); break;
992 case Action::PrecompileJobClass:
993 T = new tools::gcc::Precompile(*this); break;
994 case Action::AnalyzeJobClass:
995 T = new tools::Clang(*this); break;
996 case Action::CompileJobClass:
997 T = new tools::gcc::Compile(*this); break;
998 case Action::AssembleJobClass:
999 T = new tools::gcc::Assemble(*this); break;
1000 case Action::LinkJobClass:
1001 T = new tools::gcc::Link(*this); break;
Mike Stump1eb44332009-09-09 15:08:12 +00001002
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +00001003 // This is a bit ungeneric, but the only platform using a driver
1004 // driver is Darwin.
1005 case Action::LipoJobClass:
1006 T = new tools::darwin::Lipo(*this); break;
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00001007 case Action::DsymutilJobClass:
1008 T = new tools::darwin::Dsymutil(*this); break;
Eric Christopherf8571862011-08-23 17:56:55 +00001009 case Action::VerifyJobClass:
1010 T = new tools::darwin::VerifyDebug(*this); break;
Daniel Dunbar39176082009-03-20 00:20:03 +00001011 }
1012 }
1013
1014 return *T;
1015}
1016
Daniel Dunbar39176082009-03-20 00:20:03 +00001017bool Generic_GCC::IsUnwindTablesDefault() const {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +00001018 // FIXME: Gross; we should probably have some separate target
1019 // definition, possibly even reusing the one in clang.
Daniel Dunbar39176082009-03-20 00:20:03 +00001020 return getArchName() == "x86_64";
1021}
1022
1023const char *Generic_GCC::GetDefaultRelocationModel() const {
1024 return "static";
1025}
1026
1027const char *Generic_GCC::GetForcedPicModel() const {
1028 return 0;
1029}
Daniel Dunbarf3cad362009-03-25 04:13:45 +00001030
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001031/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1032/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1033/// Currently does not support anything else but compilation.
1034
1035TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
1036 : ToolChain(Host, Triple) {
1037 // Path mangling to find libexec
1038 std::string Path(getDriver().Dir);
1039
1040 Path += "/../libexec";
1041 getProgramPaths().push_back(Path);
1042}
1043
1044TCEToolChain::~TCEToolChain() {
1045 for (llvm::DenseMap<unsigned, Tool*>::iterator
1046 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1047 delete it->second;
1048}
1049
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001050bool TCEToolChain::IsMathErrnoDefault() const {
1051 return true;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001052}
1053
1054bool TCEToolChain::IsUnwindTablesDefault() const {
1055 return false;
1056}
1057
1058const char *TCEToolChain::GetDefaultRelocationModel() const {
1059 return "static";
1060}
1061
1062const char *TCEToolChain::GetForcedPicModel() const {
1063 return 0;
1064}
1065
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001066Tool &TCEToolChain::SelectTool(const Compilation &C,
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001067 const JobAction &JA,
1068 const ActionList &Inputs) const {
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001069 Action::ActionClass Key;
1070 Key = Action::AnalyzeJobClass;
1071
1072 Tool *&T = Tools[Key];
1073 if (!T) {
1074 switch (Key) {
1075 case Action::PreprocessJobClass:
1076 T = new tools::gcc::Preprocess(*this); break;
1077 case Action::AnalyzeJobClass:
1078 T = new tools::Clang(*this); break;
1079 default:
1080 assert(false && "Unsupported action for TCE target.");
1081 }
1082 }
1083 return *T;
1084}
1085
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001086/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1087
1088OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001089 : Generic_ELF(Host, Triple) {
Daniel Dunbaree788e72009-12-21 18:54:17 +00001090 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001091 getFilePaths().push_back("/usr/lib");
1092}
1093
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001094Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA,
1095 const ActionList &Inputs) const {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001096 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001097 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001098 Key = Action::AnalyzeJobClass;
1099 else
1100 Key = JA.getKind();
1101
Rafael Espindoladda5b922010-11-07 23:13:01 +00001102 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1103 options::OPT_no_integrated_as,
1104 IsIntegratedAssemblerDefault());
1105
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001106 Tool *&T = Tools[Key];
1107 if (!T) {
1108 switch (Key) {
Rafael Espindoladda5b922010-11-07 23:13:01 +00001109 case Action::AssembleJobClass: {
1110 if (UseIntegratedAs)
1111 T = new tools::ClangAs(*this);
1112 else
1113 T = new tools::openbsd::Assemble(*this);
1114 break;
1115 }
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001116 case Action::LinkJobClass:
1117 T = new tools::openbsd::Link(*this); break;
1118 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001119 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001120 }
1121 }
1122
1123 return *T;
1124}
1125
Daniel Dunbar75358d22009-03-30 21:06:03 +00001126/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1127
Daniel Dunbar214afe92010-08-02 05:43:59 +00001128FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001129 : Generic_ELF(Host, Triple) {
Daniel Dunbar214afe92010-08-02 05:43:59 +00001130
1131 // Determine if we are compiling 32-bit code on an x86_64 platform.
1132 bool Lib32 = false;
1133 if (Triple.getArch() == llvm::Triple::x86 &&
1134 llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1135 llvm::Triple::x86_64)
1136 Lib32 = true;
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001137
Roman Divacky3393cef2011-06-04 07:37:31 +00001138 if (Triple.getArch() == llvm::Triple::ppc &&
1139 llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1140 llvm::Triple::ppc64)
1141 Lib32 = true;
1142
Daniel Dunbarbc534662009-04-02 18:30:04 +00001143 if (Lib32) {
Daniel Dunbarbc534662009-04-02 18:30:04 +00001144 getFilePaths().push_back("/usr/lib32");
1145 } else {
Daniel Dunbarbc534662009-04-02 18:30:04 +00001146 getFilePaths().push_back("/usr/lib");
1147 }
Daniel Dunbar75358d22009-03-30 21:06:03 +00001148}
1149
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001150Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA,
1151 const ActionList &Inputs) const {
Daniel Dunbar75358d22009-03-30 21:06:03 +00001152 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001153 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar75358d22009-03-30 21:06:03 +00001154 Key = Action::AnalyzeJobClass;
1155 else
1156 Key = JA.getKind();
1157
Roman Divacky67dece72010-11-08 17:46:39 +00001158 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1159 options::OPT_no_integrated_as,
1160 IsIntegratedAssemblerDefault());
1161
Daniel Dunbar75358d22009-03-30 21:06:03 +00001162 Tool *&T = Tools[Key];
1163 if (!T) {
1164 switch (Key) {
Daniel Dunbar68a31d42009-03-31 17:45:15 +00001165 case Action::AssembleJobClass:
Roman Divacky67dece72010-11-08 17:46:39 +00001166 if (UseIntegratedAs)
1167 T = new tools::ClangAs(*this);
1168 else
1169 T = new tools::freebsd::Assemble(*this);
Roman Divackyfe3a7ea2010-11-08 19:39:10 +00001170 break;
Daniel Dunbar008f54a2009-04-01 19:36:32 +00001171 case Action::LinkJobClass:
1172 T = new tools::freebsd::Link(*this); break;
Daniel Dunbar75358d22009-03-30 21:06:03 +00001173 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001174 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Daniel Dunbar75358d22009-03-30 21:06:03 +00001175 }
1176 }
1177
1178 return *T;
1179}
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001180
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001181/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1182
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00001183NetBSD::NetBSD(const HostInfo &Host, const llvm::Triple& Triple,
1184 const llvm::Triple& ToolTriple)
1185 : Generic_ELF(Host, Triple), ToolTriple(ToolTriple) {
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001186
1187 // Determine if we are compiling 32-bit code on an x86_64 platform.
1188 bool Lib32 = false;
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00001189 if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
1190 Triple.getArch() == llvm::Triple::x86)
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001191 Lib32 = true;
1192
Joerg Sonnenberger05e59302011-03-21 13:59:26 +00001193 if (getDriver().UseStdLib) {
1194 if (Lib32)
1195 getFilePaths().push_back("=/usr/lib/i386");
1196 else
1197 getFilePaths().push_back("=/usr/lib");
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001198 }
1199}
1200
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001201Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA,
1202 const ActionList &Inputs) const {
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001203 Action::ActionClass Key;
1204 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1205 Key = Action::AnalyzeJobClass;
1206 else
1207 Key = JA.getKind();
1208
1209 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1210 options::OPT_no_integrated_as,
1211 IsIntegratedAssemblerDefault());
1212
1213 Tool *&T = Tools[Key];
1214 if (!T) {
1215 switch (Key) {
1216 case Action::AssembleJobClass:
1217 if (UseIntegratedAs)
1218 T = new tools::ClangAs(*this);
1219 else
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00001220 T = new tools::netbsd::Assemble(*this, ToolTriple);
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001221 break;
1222 case Action::LinkJobClass:
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00001223 T = new tools::netbsd::Link(*this, ToolTriple);
1224 break;
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001225 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001226 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001227 }
1228 }
1229
1230 return *T;
1231}
1232
Chris Lattner38e317d2010-07-07 16:01:42 +00001233/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1234
1235Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple)
1236 : Generic_GCC(Host, Triple) {
1237 getFilePaths().push_back(getDriver().Dir + "/../lib");
1238 getFilePaths().push_back("/usr/lib");
1239 getFilePaths().push_back("/usr/gnu/lib");
1240 getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
1241}
1242
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001243Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA,
1244 const ActionList &Inputs) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00001245 Action::ActionClass Key;
1246 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1247 Key = Action::AnalyzeJobClass;
1248 else
1249 Key = JA.getKind();
1250
1251 Tool *&T = Tools[Key];
1252 if (!T) {
1253 switch (Key) {
1254 case Action::AssembleJobClass:
1255 T = new tools::minix::Assemble(*this); break;
1256 case Action::LinkJobClass:
1257 T = new tools::minix::Link(*this); break;
1258 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001259 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Chris Lattner38e317d2010-07-07 16:01:42 +00001260 }
1261 }
1262
1263 return *T;
1264}
1265
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001266/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1267
1268AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
1269 : Generic_GCC(Host, Triple) {
1270
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001271 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer86643b82011-03-01 22:50:47 +00001272 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001273 getProgramPaths().push_back(getDriver().Dir);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001274
Daniel Dunbaree788e72009-12-21 18:54:17 +00001275 getFilePaths().push_back(getDriver().Dir + "/../lib");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001276 getFilePaths().push_back("/usr/lib");
1277 getFilePaths().push_back("/usr/sfw/lib");
1278 getFilePaths().push_back("/opt/gcc4/lib");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00001279 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001280
1281}
1282
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001283Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA,
1284 const ActionList &Inputs) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001285 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001286 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001287 Key = Action::AnalyzeJobClass;
1288 else
1289 Key = JA.getKind();
1290
1291 Tool *&T = Tools[Key];
1292 if (!T) {
1293 switch (Key) {
1294 case Action::AssembleJobClass:
1295 T = new tools::auroraux::Assemble(*this); break;
1296 case Action::LinkJobClass:
1297 T = new tools::auroraux::Link(*this); break;
1298 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001299 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001300 }
1301 }
1302
1303 return *T;
1304}
1305
1306
Eli Friedman6b3454a2009-05-26 07:52:18 +00001307/// Linux toolchain (very bare-bones at the moment).
1308
Rafael Espindolac1da9812010-11-07 20:14:31 +00001309enum LinuxDistro {
Chandler Carruth3fd345a2011-02-25 06:39:53 +00001310 ArchLinux,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001311 DebianLenny,
1312 DebianSqueeze,
Eli Friedman0b200f62011-06-02 21:36:53 +00001313 DebianWheezy,
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001314 Exherbo,
Chris Lattnerd753b562011-05-22 05:36:06 +00001315 RHEL4,
1316 RHEL5,
1317 RHEL6,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001318 Fedora13,
1319 Fedora14,
Eric Christopher8f1cc072011-04-06 18:22:53 +00001320 Fedora15,
1321 FedoraRawhide,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001322 OpenSuse11_3,
David Chisnallde5c0482011-05-19 13:26:33 +00001323 OpenSuse11_4,
1324 OpenSuse12_1,
Douglas Gregor814638e2011-03-14 15:39:50 +00001325 UbuntuHardy,
1326 UbuntuIntrepid,
Rafael Espindola021aaa42010-11-10 05:00:22 +00001327 UbuntuJaunty,
Zhongxing Xu5ede8072010-11-15 09:01:52 +00001328 UbuntuKarmic,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001329 UbuntuLucid,
1330 UbuntuMaverick,
Ted Kremenek43ac2972011-04-05 22:04:27 +00001331 UbuntuNatty,
Benjamin Kramer25a857b2011-06-05 16:08:59 +00001332 UbuntuOneiric,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001333 UnknownDistro
1334};
1335
Chris Lattnerd753b562011-05-22 05:36:06 +00001336static bool IsRedhat(enum LinuxDistro Distro) {
Eric Christopher8f1cc072011-04-06 18:22:53 +00001337 return Distro == Fedora13 || Distro == Fedora14 ||
Rafael Espindola5a640ef2011-06-03 15:23:24 +00001338 Distro == Fedora15 || Distro == FedoraRawhide ||
1339 Distro == RHEL4 || Distro == RHEL5 || Distro == RHEL6;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001340}
1341
1342static bool IsOpenSuse(enum LinuxDistro Distro) {
David Chisnallde5c0482011-05-19 13:26:33 +00001343 return Distro == OpenSuse11_3 || Distro == OpenSuse11_4 ||
1344 Distro == OpenSuse12_1;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001345}
1346
1347static bool IsDebian(enum LinuxDistro Distro) {
Eli Friedman0b200f62011-06-02 21:36:53 +00001348 return Distro == DebianLenny || Distro == DebianSqueeze ||
1349 Distro == DebianWheezy;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001350}
1351
1352static bool IsUbuntu(enum LinuxDistro Distro) {
Douglas Gregor814638e2011-03-14 15:39:50 +00001353 return Distro == UbuntuHardy || Distro == UbuntuIntrepid ||
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001354 Distro == UbuntuLucid || Distro == UbuntuMaverick ||
Ted Kremenek43ac2972011-04-05 22:04:27 +00001355 Distro == UbuntuJaunty || Distro == UbuntuKarmic ||
Benjamin Kramer25a857b2011-06-05 16:08:59 +00001356 Distro == UbuntuNatty || Distro == UbuntuOneiric;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001357}
1358
1359static bool IsDebianBased(enum LinuxDistro Distro) {
1360 return IsDebian(Distro) || IsUbuntu(Distro);
1361}
1362
1363static bool HasMultilib(llvm::Triple::ArchType Arch, enum LinuxDistro Distro) {
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001364 if (Arch == llvm::Triple::x86_64) {
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001365 bool Exists;
1366 if (Distro == Exherbo &&
1367 (llvm::sys::fs::exists("/usr/lib32/libc.so", Exists) || !Exists))
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001368 return false;
1369
Rafael Espindolac1da9812010-11-07 20:14:31 +00001370 return true;
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001371 }
Ted Kremenek43ac2972011-04-05 22:04:27 +00001372 if (Arch == llvm::Triple::ppc64)
1373 return true;
Eric Christopherf8571862011-08-23 17:56:55 +00001374 if ((Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc) &&
Eric Christopher9af535a2011-06-03 13:28:31 +00001375 IsDebianBased(Distro))
Rafael Espindolac1da9812010-11-07 20:14:31 +00001376 return true;
1377 return false;
1378}
1379
1380static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) {
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00001381 llvm::OwningPtr<llvm::MemoryBuffer> File;
1382 if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001383 StringRef Data = File.get()->getBuffer();
1384 SmallVector<StringRef, 8> Lines;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001385 Data.split(Lines, "\n");
1386 for (unsigned int i = 0, s = Lines.size(); i < s; ++ i) {
Douglas Gregor814638e2011-03-14 15:39:50 +00001387 if (Lines[i] == "DISTRIB_CODENAME=hardy")
1388 return UbuntuHardy;
Ted Kremenek43ac2972011-04-05 22:04:27 +00001389 else if (Lines[i] == "DISTRIB_CODENAME=intrepid")
1390 return UbuntuIntrepid;
Rafael Espindola021aaa42010-11-10 05:00:22 +00001391 else if (Lines[i] == "DISTRIB_CODENAME=jaunty")
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00001392 return UbuntuJaunty;
Zhongxing Xu5ede8072010-11-15 09:01:52 +00001393 else if (Lines[i] == "DISTRIB_CODENAME=karmic")
1394 return UbuntuKarmic;
Ted Kremenek43ac2972011-04-05 22:04:27 +00001395 else if (Lines[i] == "DISTRIB_CODENAME=lucid")
1396 return UbuntuLucid;
1397 else if (Lines[i] == "DISTRIB_CODENAME=maverick")
1398 return UbuntuMaverick;
1399 else if (Lines[i] == "DISTRIB_CODENAME=natty")
1400 return UbuntuNatty;
Benjamin Kramer25a857b2011-06-05 16:08:59 +00001401 else if (Lines[i] == "DISTRIB_CODENAME=oneiric")
1402 return UbuntuOneiric;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001403 }
1404 return UnknownDistro;
1405 }
1406
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00001407 if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001408 StringRef Data = File.get()->getBuffer();
Eric Christopher8f1cc072011-04-06 18:22:53 +00001409 if (Data.startswith("Fedora release 15"))
1410 return Fedora15;
1411 else if (Data.startswith("Fedora release 14"))
Rafael Espindolac1da9812010-11-07 20:14:31 +00001412 return Fedora14;
Eric Christopher8f1cc072011-04-06 18:22:53 +00001413 else if (Data.startswith("Fedora release 13"))
Rafael Espindolac1da9812010-11-07 20:14:31 +00001414 return Fedora13;
Eric Christopher8f1cc072011-04-06 18:22:53 +00001415 else if (Data.startswith("Fedora release") &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00001416 Data.find("Rawhide") != StringRef::npos)
Eric Christopher8f1cc072011-04-06 18:22:53 +00001417 return FedoraRawhide;
Chris Lattnerd753b562011-05-22 05:36:06 +00001418 else if (Data.startswith("Red Hat Enterprise Linux") &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00001419 Data.find("release 6") != StringRef::npos)
Chris Lattnerd753b562011-05-22 05:36:06 +00001420 return RHEL6;
Rafael Espindola5a640ef2011-06-03 15:23:24 +00001421 else if ((Data.startswith("Red Hat Enterprise Linux") ||
1422 Data.startswith("CentOS")) &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00001423 Data.find("release 5") != StringRef::npos)
Chris Lattnerd753b562011-05-22 05:36:06 +00001424 return RHEL5;
Rafael Espindola5a640ef2011-06-03 15:23:24 +00001425 else if ((Data.startswith("Red Hat Enterprise Linux") ||
1426 Data.startswith("CentOS")) &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00001427 Data.find("release 4") != StringRef::npos)
Chris Lattnerd753b562011-05-22 05:36:06 +00001428 return RHEL4;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001429 return UnknownDistro;
1430 }
1431
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00001432 if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001433 StringRef Data = File.get()->getBuffer();
Rafael Espindolac1da9812010-11-07 20:14:31 +00001434 if (Data[0] == '5')
1435 return DebianLenny;
1436 else if (Data.startswith("squeeze/sid"))
1437 return DebianSqueeze;
Eli Friedman0b200f62011-06-02 21:36:53 +00001438 else if (Data.startswith("wheezy/sid"))
1439 return DebianWheezy;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001440 return UnknownDistro;
1441 }
1442
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00001443 if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001444 StringRef Data = File.get()->getBuffer();
Rafael Espindolac1da9812010-11-07 20:14:31 +00001445 if (Data.startswith("openSUSE 11.3"))
1446 return OpenSuse11_3;
David Chisnallde5c0482011-05-19 13:26:33 +00001447 else if (Data.startswith("openSUSE 11.4"))
1448 return OpenSuse11_4;
1449 else if (Data.startswith("openSUSE 12.1"))
1450 return OpenSuse12_1;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001451 return UnknownDistro;
1452 }
1453
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001454 bool Exists;
1455 if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001456 return Exherbo;
1457
Chandler Carruth3fd345a2011-02-25 06:39:53 +00001458 if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
1459 return ArchLinux;
1460
Rafael Espindolac1da9812010-11-07 20:14:31 +00001461 return UnknownDistro;
1462}
1463
Rafael Espindola14ea13c2011-06-02 22:18:46 +00001464static std::string findGCCBaseLibDir(const std::string &GccTriple) {
Chandler Carruth169dd312011-06-08 10:14:38 +00001465 // FIXME: Using CXX_INCLUDE_ROOT is here is a bit of a hack, but
1466 // avoids adding yet another option to configure/cmake.
1467 // It would probably be cleaner to break it in two variables
1468 // CXX_GCC_ROOT with just /foo/bar
1469 // CXX_GCC_VER with 4.5.2
1470 // Then we would have
1471 // CXX_INCLUDE_ROOT = CXX_GCC_ROOT/include/c++/CXX_GCC_VER
1472 // and this function would return
1473 // CXX_GCC_ROOT/lib/gcc/CXX_INCLUDE_ARCH/CXX_GCC_VER
1474 llvm::SmallString<128> CxxIncludeRoot(CXX_INCLUDE_ROOT);
1475 if (CxxIncludeRoot != "") {
1476 // This is of the form /foo/bar/include/c++/4.5.2/
1477 if (CxxIncludeRoot.back() == '/')
1478 llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the /
Chris Lattner5f9e2722011-07-23 10:55:15 +00001479 StringRef Version = llvm::sys::path::filename(CxxIncludeRoot);
Chandler Carruth169dd312011-06-08 10:14:38 +00001480 llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the version
1481 llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the c++
1482 llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the include
1483 std::string ret(CxxIncludeRoot.c_str());
1484 ret.append("/lib/gcc/");
1485 ret.append(CXX_INCLUDE_ARCH);
1486 ret.append("/");
1487 ret.append(Version);
1488 return ret;
Rafael Espindola14ea13c2011-06-02 22:18:46 +00001489 }
Chandler Carruth37187cc2011-07-02 00:51:03 +00001490 static const char* GccVersions[] = {"4.6.1", "4.6.0", "4.6",
Eli Friedmanb1f2f472011-08-29 18:56:43 +00001491 "4.5.3", "4.5.2", "4.5.1", "4.5",
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001492 "4.4.5", "4.4.4", "4.4.3", "4.4",
1493 "4.3.4", "4.3.3", "4.3.2", "4.3",
1494 "4.2.4", "4.2.3", "4.2.2", "4.2.1",
1495 "4.2", "4.1.1"};
Rafael Espindola14ea13c2011-06-02 22:18:46 +00001496 bool Exists;
1497 for (unsigned i = 0; i < sizeof(GccVersions)/sizeof(char*); ++i) {
1498 std::string Suffix = GccTriple + "/" + GccVersions[i];
1499 std::string t1 = "/usr/lib/gcc/" + Suffix;
1500 if (!llvm::sys::fs::exists(t1 + "/crtbegin.o", Exists) && Exists)
1501 return t1;
1502 std::string t2 = "/usr/lib64/gcc/" + Suffix;
1503 if (!llvm::sys::fs::exists(t2 + "/crtbegin.o", Exists) && Exists)
1504 return t2;
1505 std::string t3 = "/usr/lib/" + GccTriple + "/gcc/" + Suffix;
1506 if (!llvm::sys::fs::exists(t3 + "/crtbegin.o", Exists) && Exists)
1507 return t3;
1508 }
1509 return "";
1510}
1511
Nick Lewycky3fdcc6f2010-12-31 17:31:54 +00001512Linux::Linux(const HostInfo &Host, const llvm::Triple &Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001513 : Generic_ELF(Host, Triple) {
Rafael Espindolac1da9812010-11-07 20:14:31 +00001514 llvm::Triple::ArchType Arch =
1515 llvm::Triple(getDriver().DefaultHostTriple).getArch();
Daniel Dunbara9822de2009-08-06 01:47:11 +00001516
Rafael Espindolac1da9812010-11-07 20:14:31 +00001517 std::string Suffix32 = "";
1518 if (Arch == llvm::Triple::x86_64)
1519 Suffix32 = "/32";
Daniel Dunbara9822de2009-08-06 01:47:11 +00001520
Rafael Espindolac1da9812010-11-07 20:14:31 +00001521 std::string Suffix64 = "";
Ted Kremenek43ac2972011-04-05 22:04:27 +00001522 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001523 Suffix64 = "/64";
1524
1525 std::string Lib32 = "lib";
1526
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001527 bool Exists;
1528 if (!llvm::sys::fs::exists("/lib32", Exists) && Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001529 Lib32 = "lib32";
1530
1531 std::string Lib64 = "lib";
Michael J. Spencer2dea7c72011-01-12 23:54:48 +00001532 bool Symlink;
Chris Lattner48aef362011-01-13 01:35:58 +00001533 if (!llvm::sys::fs::exists("/lib64", Exists) && Exists &&
1534 (llvm::sys::fs::is_symlink("/lib64", Symlink) || !Symlink))
Rafael Espindolac1da9812010-11-07 20:14:31 +00001535 Lib64 = "lib64";
1536
1537 std::string GccTriple = "";
Douglas Gregorf0594d82011-03-06 19:11:49 +00001538 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001539 if (!llvm::sys::fs::exists("/usr/lib/gcc/arm-linux-gnueabi", Exists) &&
1540 Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001541 GccTriple = "arm-linux-gnueabi";
1542 } else if (Arch == llvm::Triple::x86_64) {
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001543 if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-linux-gnu", Exists) &&
1544 Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001545 GccTriple = "x86_64-linux-gnu";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001546 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-unknown-linux-gnu",
1547 Exists) && Exists)
Rafael Espindola53dd00b2010-11-17 00:25:26 +00001548 GccTriple = "x86_64-unknown-linux-gnu";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001549 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-pc-linux-gnu",
1550 Exists) && Exists)
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001551 GccTriple = "x86_64-pc-linux-gnu";
NAKAMURA Takumic3703982011-06-16 12:43:57 +00001552 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-redhat-linux6E",
1553 Exists) && Exists)
1554 GccTriple = "x86_64-redhat-linux6E";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001555 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-redhat-linux",
1556 Exists) && Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001557 GccTriple = "x86_64-redhat-linux";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001558 else if (!llvm::sys::fs::exists("/usr/lib64/gcc/x86_64-suse-linux",
1559 Exists) && Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001560 GccTriple = "x86_64-suse-linux";
Nick Lewyckye10f9002011-02-01 23:03:29 +00001561 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-manbo-linux-gnu",
1562 Exists) && Exists)
1563 GccTriple = "x86_64-manbo-linux-gnu";
Nico Weber80585d82011-04-25 03:17:35 +00001564 else if (!llvm::sys::fs::exists("/usr/lib/x86_64-linux-gnu/gcc",
1565 Exists) && Exists)
1566 GccTriple = "x86_64-linux-gnu";
Chad Rosierf59f5da2011-08-26 00:49:52 +00001567 else if (!llvm::sys::fs::exists("/usr/lib64/gcc/x86_64-slackware-linux",
1568 Exists) && Exists)
Eli Friedmancb6239a2011-08-17 18:17:26 +00001569 GccTriple = "x86_64-slackware-linux";
Rafael Espindolac1da9812010-11-07 20:14:31 +00001570 } else if (Arch == llvm::Triple::x86) {
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001571 if (!llvm::sys::fs::exists("/usr/lib/gcc/i686-linux-gnu", Exists) && Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001572 GccTriple = "i686-linux-gnu";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001573 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i686-pc-linux-gnu", Exists) &&
1574 Exists)
Nuno Lopes2a69ddd2010-11-19 17:26:57 +00001575 GccTriple = "i686-pc-linux-gnu";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001576 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i486-linux-gnu", Exists) &&
1577 Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001578 GccTriple = "i486-linux-gnu";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001579 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i686-redhat-linux", Exists) &&
1580 Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001581 GccTriple = "i686-redhat-linux";
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001582 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i586-suse-linux", Exists) &&
1583 Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001584 GccTriple = "i586-suse-linux";
Ted Kremenekd130c7d2011-04-18 17:50:19 +00001585 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i486-slackware-linux", Exists)
1586 && Exists)
1587 GccTriple = "i486-slackware-linux";
Ted Kremenek43ac2972011-04-05 22:04:27 +00001588 } else if (Arch == llvm::Triple::ppc) {
1589 if (!llvm::sys::fs::exists("/usr/lib/powerpc-linux-gnu", Exists) && Exists)
1590 GccTriple = "powerpc-linux-gnu";
Eric Christopher9af535a2011-06-03 13:28:31 +00001591 else if (!llvm::sys::fs::exists("/usr/lib/gcc/powerpc-unknown-linux-gnu",
1592 Exists) && Exists)
Ted Kremenek43ac2972011-04-05 22:04:27 +00001593 GccTriple = "powerpc-unknown-linux-gnu";
1594 } else if (Arch == llvm::Triple::ppc64) {
Eric Christopher9af535a2011-06-03 13:28:31 +00001595 if (!llvm::sys::fs::exists("/usr/lib/gcc/powerpc64-unknown-linux-gnu",
1596 Exists) && Exists)
Ted Kremenek43ac2972011-04-05 22:04:27 +00001597 GccTriple = "powerpc64-unknown-linux-gnu";
Eric Christopher9af535a2011-06-03 13:28:31 +00001598 else if (!llvm::sys::fs::exists("/usr/lib64/gcc/"
Eric Christopherf8571862011-08-23 17:56:55 +00001599 "powerpc64-unknown-linux-gnu", Exists) &&
Eric Christopher9af535a2011-06-03 13:28:31 +00001600 Exists)
Ted Kremenek43ac2972011-04-05 22:04:27 +00001601 GccTriple = "powerpc64-unknown-linux-gnu";
Rafael Espindolac1da9812010-11-07 20:14:31 +00001602 }
1603
Rafael Espindola14ea13c2011-06-02 22:18:46 +00001604 std::string Base = findGCCBaseLibDir(GccTriple);
Rafael Espindolac1da9812010-11-07 20:14:31 +00001605 path_list &Paths = getFilePaths();
Eric Christopherf8571862011-08-23 17:56:55 +00001606 bool Is32Bits = (getArch() == llvm::Triple::x86 ||
Eric Christopher9af535a2011-06-03 13:28:31 +00001607 getArch() == llvm::Triple::ppc);
Rafael Espindolac1da9812010-11-07 20:14:31 +00001608
1609 std::string Suffix;
1610 std::string Lib;
1611
1612 if (Is32Bits) {
1613 Suffix = Suffix32;
1614 Lib = Lib32;
1615 } else {
1616 Suffix = Suffix64;
1617 Lib = Lib64;
1618 }
1619
1620 llvm::sys::Path LinkerPath(Base + "/../../../../" + GccTriple + "/bin/ld");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +00001621 if (!llvm::sys::fs::exists(LinkerPath.str(), Exists) && Exists)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001622 Linker = LinkerPath.str();
1623 else
1624 Linker = GetProgramPath("ld");
1625
1626 LinuxDistro Distro = DetectLinuxDistro(Arch);
1627
Chris Lattner64a89172011-05-22 16:45:07 +00001628 if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
Rafael Espindola94c80222010-11-08 14:48:47 +00001629 ExtraOpts.push_back("-z");
1630 ExtraOpts.push_back("relro");
1631 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00001632
Douglas Gregorf0594d82011-03-06 19:11:49 +00001633 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001634 ExtraOpts.push_back("-X");
1635
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001636 if (IsRedhat(Distro) || IsOpenSuse(Distro) || Distro == UbuntuMaverick ||
Benjamin Kramer25a857b2011-06-05 16:08:59 +00001637 Distro == UbuntuNatty || Distro == UbuntuOneiric)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001638 ExtraOpts.push_back("--hash-style=gnu");
1639
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001640 if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
Chris Lattner64a89172011-05-22 16:45:07 +00001641 Distro == UbuntuJaunty || Distro == UbuntuKarmic)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001642 ExtraOpts.push_back("--hash-style=both");
1643
Chris Lattnerd753b562011-05-22 05:36:06 +00001644 if (IsRedhat(Distro))
Rafael Espindolac1da9812010-11-07 20:14:31 +00001645 ExtraOpts.push_back("--no-add-needed");
1646
Eli Friedman0b200f62011-06-02 21:36:53 +00001647 if (Distro == DebianSqueeze || Distro == DebianWheezy ||
Rafael Espindola5a640ef2011-06-03 15:23:24 +00001648 IsOpenSuse(Distro) ||
1649 (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
1650 Distro == UbuntuLucid ||
Eli Friedman0b200f62011-06-02 21:36:53 +00001651 Distro == UbuntuMaverick || Distro == UbuntuKarmic ||
Benjamin Kramer25a857b2011-06-05 16:08:59 +00001652 Distro == UbuntuNatty || Distro == UbuntuOneiric)
Rafael Espindolac1da9812010-11-07 20:14:31 +00001653 ExtraOpts.push_back("--build-id");
1654
Chris Lattner64a89172011-05-22 16:45:07 +00001655 if (IsOpenSuse(Distro))
Chandler Carruthf0b60ec2011-05-24 07:51:17 +00001656 ExtraOpts.push_back("--enable-new-dtags");
Chris Lattner64a89172011-05-22 16:45:07 +00001657
Chandler Carruth3fd345a2011-02-25 06:39:53 +00001658 if (Distro == ArchLinux)
1659 Lib = "lib";
1660
Rafael Espindolac1da9812010-11-07 20:14:31 +00001661 Paths.push_back(Base + Suffix);
1662 if (HasMultilib(Arch, Distro)) {
1663 if (IsOpenSuse(Distro) && Is32Bits)
1664 Paths.push_back(Base + "/../../../../" + GccTriple + "/lib/../lib");
1665 Paths.push_back(Base + "/../../../../" + Lib);
Rafael Espindolac1da9812010-11-07 20:14:31 +00001666 }
Rafael Espindolac7409a02011-06-03 15:39:42 +00001667
1668 // FIXME: This is in here to find crt1.o. It is provided by libc, and
1669 // libc (like gcc), can be installed in any directory. Once we are
1670 // fetching this from a config file, we should have a libc prefix.
1671 Paths.push_back("/lib/../" + Lib);
1672 Paths.push_back("/usr/lib/../" + Lib);
1673
Rafael Espindolac1da9812010-11-07 20:14:31 +00001674 if (!Suffix.empty())
1675 Paths.push_back(Base);
1676 if (IsOpenSuse(Distro))
1677 Paths.push_back(Base + "/../../../../" + GccTriple + "/lib");
1678 Paths.push_back(Base + "/../../..");
1679 if (Arch == getArch() && IsUbuntu(Distro))
1680 Paths.push_back("/usr/lib/" + GccTriple);
1681}
1682
1683bool Linux::HasNativeLLVMSupport() const {
1684 return true;
Eli Friedman6b3454a2009-05-26 07:52:18 +00001685}
1686
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001687Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA,
1688 const ActionList &Inputs) const {
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001689 Action::ActionClass Key;
1690 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1691 Key = Action::AnalyzeJobClass;
1692 else
1693 Key = JA.getKind();
1694
Rafael Espindoladda5b922010-11-07 23:13:01 +00001695 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1696 options::OPT_no_integrated_as,
1697 IsIntegratedAssemblerDefault());
1698
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001699 Tool *&T = Tools[Key];
1700 if (!T) {
1701 switch (Key) {
1702 case Action::AssembleJobClass:
Rafael Espindoladda5b922010-11-07 23:13:01 +00001703 if (UseIntegratedAs)
1704 T = new tools::ClangAs(*this);
1705 else
1706 T = new tools::linuxtools::Assemble(*this);
1707 break;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001708 case Action::LinkJobClass:
1709 T = new tools::linuxtools::Link(*this); break;
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001710 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001711 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00001712 }
1713 }
1714
1715 return *T;
1716}
1717
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001718/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
1719
Daniel Dunbarcb8ab232009-05-22 02:53:45 +00001720DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
Rafael Espindolae43cfa12010-10-29 20:14:02 +00001721 : Generic_ELF(Host, Triple) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001722
1723 // Path mangling to find libexec
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001724 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer86643b82011-03-01 22:50:47 +00001725 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001726 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001727
Daniel Dunbaree788e72009-12-21 18:54:17 +00001728 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001729 getFilePaths().push_back("/usr/lib");
1730 getFilePaths().push_back("/usr/lib/gcc41");
1731}
1732
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001733Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA,
1734 const ActionList &Inputs) const {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001735 Action::ActionClass Key;
Daniel Dunbaree788e72009-12-21 18:54:17 +00001736 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001737 Key = Action::AnalyzeJobClass;
1738 else
1739 Key = JA.getKind();
1740
1741 Tool *&T = Tools[Key];
1742 if (!T) {
1743 switch (Key) {
1744 case Action::AssembleJobClass:
1745 T = new tools::dragonfly::Assemble(*this); break;
1746 case Action::LinkJobClass:
1747 T = new tools::dragonfly::Link(*this); break;
1748 default:
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001749 T = &Generic_GCC::SelectTool(C, JA, Inputs);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001750 }
1751 }
1752
1753 return *T;
1754}
Michael J. Spencerff58e362010-08-21 21:55:07 +00001755
1756Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple)
1757 : ToolChain(Host, Triple) {
1758}
1759
Daniel Dunbarac0659a2011-03-18 20:14:00 +00001760Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA,
1761 const ActionList &Inputs) const {
Michael J. Spencerff58e362010-08-21 21:55:07 +00001762 Action::ActionClass Key;
1763 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1764 Key = Action::AnalyzeJobClass;
1765 else
1766 Key = JA.getKind();
1767
Chad Rosierc57114a2011-07-20 19:14:30 +00001768 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1769 options::OPT_no_integrated_as,
1770 IsIntegratedAssemblerDefault());
1771
Michael J. Spencerff58e362010-08-21 21:55:07 +00001772 Tool *&T = Tools[Key];
1773 if (!T) {
1774 switch (Key) {
1775 case Action::InputClass:
1776 case Action::BindArchClass:
Chandler Carruthe97673f2010-08-22 06:56:37 +00001777 case Action::LipoJobClass:
1778 case Action::DsymutilJobClass:
Eric Christopherf8571862011-08-23 17:56:55 +00001779 case Action::VerifyJobClass:
Michael J. Spencerff58e362010-08-21 21:55:07 +00001780 assert(0 && "Invalid tool kind.");
1781 case Action::PreprocessJobClass:
1782 case Action::PrecompileJobClass:
1783 case Action::AnalyzeJobClass:
1784 case Action::CompileJobClass:
1785 T = new tools::Clang(*this); break;
1786 case Action::AssembleJobClass:
Chad Rosierc57114a2011-07-20 19:14:30 +00001787 if (!UseIntegratedAs && getTriple().getEnvironment() == llvm::Triple::MachO)
1788 T = new tools::darwin::Assemble(*this);
1789 else
1790 T = new tools::ClangAs(*this);
1791 break;
Michael J. Spencerff58e362010-08-21 21:55:07 +00001792 case Action::LinkJobClass:
1793 T = new tools::visualstudio::Link(*this); break;
1794 }
1795 }
1796
1797 return *T;
1798}
1799
1800bool Windows::IsIntegratedAssemblerDefault() const {
1801 return true;
1802}
1803
1804bool Windows::IsUnwindTablesDefault() const {
1805 // FIXME: Gross; we should probably have some separate target
1806 // definition, possibly even reusing the one in clang.
1807 return getArchName() == "x86_64";
1808}
1809
1810const char *Windows::GetDefaultRelocationModel() const {
1811 return "static";
1812}
1813
1814const char *Windows::GetForcedPicModel() const {
1815 if (getArchName() == "x86_64")
1816 return "pic";
1817 return 0;
1818}