blob: 47a5f33017800dbfa57c688c936412e07ff2691d [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"
Chandler Carruth55fc8732012-12-04 09:13:33 +000011#include "SanitizerArgs.h"
12#include "clang/Basic/ObjCRuntime.h"
13#include "clang/Basic/Version.h"
Daniel Dunbar0f602de2010-05-20 21:48:38 +000014#include "clang/Driver/Compilation.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000015#include "clang/Driver/Driver.h"
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +000016#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar265e9ef2009-11-19 04:25:22 +000017#include "clang/Driver/Options.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000018#include "llvm/ADT/STLExtras.h"
Daniel Dunbar00577ad2010-08-23 22:35:37 +000019#include "llvm/ADT/SmallString.h"
Daniel Dunbarc50b00d2009-03-23 16:15:50 +000020#include "llvm/ADT/StringExtras.h"
Bob Wilsona59956b2011-10-07 00:37:57 +000021#include "llvm/ADT/StringSwitch.h"
Reid Klecknerb1e25a12013-06-14 17:17:23 +000022#include "llvm/Option/Arg.h"
23#include "llvm/Option/ArgList.h"
24#include "llvm/Option/OptTable.h"
25#include "llvm/Option/Option.h"
Daniel Dunbar84ec96c2009-09-09 22:33:15 +000026#include "llvm/Support/ErrorHandling.h"
Michael J. Spencer32bef4e2011-01-10 02:34:13 +000027#include "llvm/Support/FileSystem.h"
Rafael Espindolac1da9812010-11-07 20:14:31 +000028#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000029#include "llvm/Support/Path.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000030#include "llvm/Support/raw_ostream.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000031#include "llvm/Support/system_error.h"
NAKAMURA Takumi55426352012-12-04 14:31:59 +000032
33// FIXME: This needs to be listed last until we fix the broken include guards
34// in these files and the LLVM config.h files.
35#include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
36
Daniel Dunbarf36a06a2009-04-10 21:00:07 +000037#include <cstdlib> // ::getenv
38
Daniel Dunbar39176082009-03-20 00:20:03 +000039using namespace clang::driver;
40using namespace clang::driver::toolchains;
Chris Lattner5f9e2722011-07-23 10:55:15 +000041using namespace clang;
Reid Klecknerb1e25a12013-06-14 17:17:23 +000042using namespace llvm::opt;
Daniel Dunbar39176082009-03-20 00:20:03 +000043
Daniel Dunbarf3955282009-09-04 18:34:51 +000044/// Darwin - Darwin tool chain for i386 and x86_64.
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +000045
Rafael Espindolaaf370e62013-03-18 18:10:27 +000046Darwin::Darwin(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
47 : ToolChain(D, Triple, Args), TargetInitialized(false)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +000048{
Bob Wilson10853772012-01-31 21:30:03 +000049 // Compute the initial Darwin version from the triple
50 unsigned Major, Minor, Micro;
Bob Wilson4c5ffb32012-01-31 22:43:59 +000051 if (!Triple.getMacOSXVersion(Major, Minor, Micro))
52 getDriver().Diag(diag::err_drv_invalid_darwin_version) <<
53 Triple.getOSName();
54 llvm::raw_string_ostream(MacosxVersionMin)
55 << Major << '.' << Minor << '.' << Micro;
56
Bob Wilson10853772012-01-31 21:30:03 +000057 // FIXME: DarwinVersion is only used to find GCC's libexec directory.
58 // It should be removed when we stop supporting that.
59 DarwinVersion[0] = Minor + 4;
60 DarwinVersion[1] = Micro;
61 DarwinVersion[2] = 0;
Chad Rosierc793ea42012-05-09 18:46:30 +000062
63 // Compute the initial iOS version from the triple
Chad Rosier8c990272012-05-09 18:51:13 +000064 Triple.getiOSVersion(Major, Minor, Micro);
Chad Rosierc793ea42012-05-09 18:46:30 +000065 llvm::raw_string_ostream(iOSVersionMin)
66 << Major << '.' << Minor << '.' << Micro;
Daniel Dunbar1d4612b2009-09-18 08:15:13 +000067}
68
Daniel Dunbar41800112010-08-02 05:43:56 +000069types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
70 types::ID Ty = types::lookupTypeForExtension(Ext);
71
72 // Darwin always preprocesses assembly files (unless -x is used explicitly).
73 if (Ty == types::TY_PP_Asm)
74 return types::TY_Asm;
75
76 return Ty;
77}
78
Daniel Dunbarb993f5d2010-09-17 00:24:52 +000079bool Darwin::HasNativeLLVMSupport() const {
80 return true;
81}
82
John McCall9f084a32011-07-06 00:26:06 +000083/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
John McCall260611a2012-06-20 06:18:46 +000084ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
Bob Wilson377e5c12012-11-09 01:59:30 +000085 if (isTargetIPhoneOS())
John McCall260611a2012-06-20 06:18:46 +000086 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
Bob Wilson377e5c12012-11-09 01:59:30 +000087 if (isNonFragile)
88 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
89 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
John McCall9f084a32011-07-06 00:26:06 +000090}
91
John McCall13db5cf2011-09-09 20:41:01 +000092/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
93bool Darwin::hasBlocksRuntime() const {
94 if (isTargetIPhoneOS())
95 return !isIPhoneOSVersionLT(3, 2);
96 else
97 return !isMacosxVersionLT(10, 6);
98}
99
Chris Lattner5f9e2722011-07-23 10:55:15 +0000100static const char *GetArmArchForMArch(StringRef Value) {
Bob Wilsona59956b2011-10-07 00:37:57 +0000101 return llvm::StringSwitch<const char*>(Value)
102 .Case("armv6k", "armv6")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000103 .Case("armv6m", "armv6m")
Bob Wilsona59956b2011-10-07 00:37:57 +0000104 .Case("armv5tej", "armv5")
105 .Case("xscale", "xscale")
106 .Case("armv4t", "armv4t")
107 .Case("armv7", "armv7")
108 .Cases("armv7a", "armv7-a", "armv7")
109 .Cases("armv7r", "armv7-r", "armv7")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000110 .Cases("armv7em", "armv7e-m", "armv7em")
Bob Wilson336bfa32012-09-29 23:52:50 +0000111 .Cases("armv7f", "armv7-f", "armv7f")
112 .Cases("armv7k", "armv7-k", "armv7k")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000113 .Cases("armv7m", "armv7-m", "armv7m")
Bob Wilson336bfa32012-09-29 23:52:50 +0000114 .Cases("armv7s", "armv7-s", "armv7s")
Joey Gouly4ec8d5b2013-06-26 17:19:48 +0000115 .Cases("armv8", "armv8a", "armv8-a", "armv8")
Bob Wilsona59956b2011-10-07 00:37:57 +0000116 .Default(0);
Daniel Dunbareeff4062010-01-22 02:04:58 +0000117}
118
Chris Lattner5f9e2722011-07-23 10:55:15 +0000119static const char *GetArmArchForMCpu(StringRef Value) {
Bob Wilsona59956b2011-10-07 00:37:57 +0000120 return llvm::StringSwitch<const char *>(Value)
121 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
122 .Cases("arm10e", "arm10tdmi", "armv5")
123 .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
124 .Case("xscale", "xscale")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000125 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "arm1176jzf-s", "armv6")
126 .Case("cortex-m0", "armv6m")
127 .Cases("cortex-a8", "cortex-r4", "cortex-a9", "cortex-a15", "armv7")
Bob Wilson336bfa32012-09-29 23:52:50 +0000128 .Case("cortex-a9-mp", "armv7f")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000129 .Case("cortex-m3", "armv7m")
130 .Case("cortex-m4", "armv7em")
Bob Wilson336bfa32012-09-29 23:52:50 +0000131 .Case("swift", "armv7s")
Bob Wilsona59956b2011-10-07 00:37:57 +0000132 .Default(0);
Daniel Dunbareeff4062010-01-22 02:04:58 +0000133}
134
Chris Lattner5f9e2722011-07-23 10:55:15 +0000135StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
Daniel Dunbareeff4062010-01-22 02:04:58 +0000136 switch (getTriple().getArch()) {
137 default:
138 return getArchName();
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000139
Douglas Gregorf0594d82011-03-06 19:11:49 +0000140 case llvm::Triple::thumb:
Daniel Dunbareeff4062010-01-22 02:04:58 +0000141 case llvm::Triple::arm: {
142 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
Richard Smith1d489cf2012-11-01 04:30:05 +0000143 if (const char *Arch = GetArmArchForMArch(A->getValue()))
Daniel Dunbareeff4062010-01-22 02:04:58 +0000144 return Arch;
145
146 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Richard Smith1d489cf2012-11-01 04:30:05 +0000147 if (const char *Arch = GetArmArchForMCpu(A->getValue()))
Daniel Dunbareeff4062010-01-22 02:04:58 +0000148 return Arch;
149
150 return "arm";
151 }
152 }
153}
154
Daniel Dunbarf3955282009-09-04 18:34:51 +0000155Darwin::~Darwin() {
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000156}
157
Chad Rosier61ab80a2011-09-20 20:44:06 +0000158std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
159 types::ID InputType) const {
160 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000161
162 // If the target isn't initialized (e.g., an unknown Darwin platform, return
163 // the default triple).
164 if (!isTargetInitialized())
165 return Triple.getTriple();
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000166
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000167 SmallString<16> Str;
Benjamin Kramer09c9a562012-03-10 20:55:36 +0000168 Str += isTargetIPhoneOS() ? "ios" : "macosx";
169 Str += getTargetVersion().getAsString();
170 Triple.setOSName(Str);
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000171
172 return Triple.getTriple();
173}
174
David Blaikie99ba9e32011-12-20 02:48:34 +0000175void Generic_ELF::anchor() {}
176
Rafael Espindolaf48b93c2013-03-20 03:05:54 +0000177Tool *Darwin::getTool(Action::ActionClass AC) const {
Rafael Espindola5b222052013-03-18 20:48:54 +0000178 switch (AC) {
Rafael Espindolaf3260562013-03-18 18:50:01 +0000179 case Action::LipoJobClass:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +0000180 if (!Lipo)
181 Lipo.reset(new tools::darwin::Lipo(*this));
182 return Lipo.get();
Rafael Espindolaf3260562013-03-18 18:50:01 +0000183 case Action::DsymutilJobClass:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +0000184 if (!Dsymutil)
185 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
186 return Dsymutil.get();
Rafael Espindolaf3260562013-03-18 18:50:01 +0000187 case Action::VerifyJobClass:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +0000188 if (!VerifyDebug)
189 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
190 return VerifyDebug.get();
Rafael Espindolac0a55d12013-03-19 00:36:57 +0000191 default:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +0000192 return ToolChain::getTool(AC);
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000193 }
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000194}
195
Rafael Espindolaf48b93c2013-03-20 03:05:54 +0000196Tool *Darwin::buildLinker() const {
197 return new tools::darwin::Link(*this);
198}
199
200Tool *Darwin::buildAssembler() const {
201 return new tools::darwin::Assemble(*this);
202}
Daniel Dunbar6cd41542009-09-18 08:15:03 +0000203
Rafael Espindolaaf370e62013-03-18 18:10:27 +0000204DarwinClang::DarwinClang(const Driver &D, const llvm::Triple& Triple,
205 const ArgList &Args)
206 : Darwin(D, Triple, Args)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000207{
Daniel Dunbar0e50ee42010-09-17 08:22:12 +0000208 getProgramPaths().push_back(getDriver().getInstalledDir());
209 if (getDriver().getInstalledDir() != getDriver().Dir)
210 getProgramPaths().push_back(getDriver().Dir);
211
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000212 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
Daniel Dunbaredf29b02010-08-01 22:29:51 +0000213 getProgramPaths().push_back(getDriver().getInstalledDir());
214 if (getDriver().getInstalledDir() != getDriver().Dir)
215 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000216}
217
John McCallf85e1932011-06-15 23:02:42 +0000218void DarwinClang::AddLinkARCArgs(const ArgList &Args,
219 ArgStringList &CmdArgs) const {
Eric Christopherf8571862011-08-23 17:56:55 +0000220
221 CmdArgs.push_back("-force_load");
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000222 SmallString<128> P(getDriver().ClangExecutable);
223 llvm::sys::path::remove_filename(P); // 'clang'
224 llvm::sys::path::remove_filename(P); // 'bin'
225 llvm::sys::path::append(P, "lib");
226 llvm::sys::path::append(P, "arc");
227 llvm::sys::path::append(P, "libarclite_");
John McCallf85e1932011-06-15 23:02:42 +0000228 // Mash in the platform.
Argyrios Kyrtzidisc19981c2011-10-18 17:40:15 +0000229 if (isTargetIOSSimulator())
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000230 P += "iphonesimulator";
Argyrios Kyrtzidisc19981c2011-10-18 17:40:15 +0000231 else if (isTargetIPhoneOS())
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000232 P += "iphoneos";
John McCallf85e1932011-06-15 23:02:42 +0000233 else
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000234 P += "macosx";
235 P += ".a";
John McCallf85e1932011-06-15 23:02:42 +0000236
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000237 CmdArgs.push_back(Args.MakeArgString(P));
John McCallf85e1932011-06-15 23:02:42 +0000238}
239
Eric Christopher3404fe72011-06-22 17:41:40 +0000240void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
Eric Christopherf8571862011-08-23 17:56:55 +0000241 ArgStringList &CmdArgs,
Alexey Samsonov69b77d72012-11-21 14:17:42 +0000242 const char *DarwinStaticLib,
243 bool AlwaysLink) const {
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000244 SmallString<128> P(getDriver().ResourceDir);
245 llvm::sys::path::append(P, "lib");
246 llvm::sys::path::append(P, "darwin");
247 llvm::sys::path::append(P, DarwinStaticLib);
Eric Christopherf8571862011-08-23 17:56:55 +0000248
Eric Christopher3404fe72011-06-22 17:41:40 +0000249 // For now, allow missing resource libraries to support developers who may
Alexey Samsonov69b77d72012-11-21 14:17:42 +0000250 // not have compiler-rt checked out or integrated into their build (unless
251 // we explicitly force linking with this library).
Rafael Espindola40e6b302013-06-25 15:14:22 +0000252 if (AlwaysLink || llvm::sys::fs::exists(P.str()))
Eric Christopher3404fe72011-06-22 17:41:40 +0000253 CmdArgs.push_back(Args.MakeArgString(P.str()));
254}
255
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000256void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
257 ArgStringList &CmdArgs) const {
Daniel Dunbarc24767c2011-12-07 23:03:15 +0000258 // Darwin only supports the compiler-rt based runtime libraries.
259 switch (GetRuntimeLibType(Args)) {
260 case ToolChain::RLT_CompilerRT:
261 break;
262 default:
263 getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
Richard Smith1d489cf2012-11-01 04:30:05 +0000264 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
Daniel Dunbarc24767c2011-12-07 23:03:15 +0000265 return;
266 }
267
Daniel Dunbareec99102010-01-22 03:38:14 +0000268 // Darwin doesn't support real static executables, don't link any runtime
269 // libraries with -static.
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000270 if (Args.hasArg(options::OPT_static) ||
271 Args.hasArg(options::OPT_fapple_kext) ||
272 Args.hasArg(options::OPT_mkernel))
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000273 return;
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000274
275 // Reject -static-libgcc for now, we can deal with this when and if someone
276 // cares. This is useful in situations where someone wants to statically link
277 // something like libstdc++, and needs its runtime support routines.
278 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000279 getDriver().Diag(diag::err_drv_unsupported_opt)
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000280 << A->getAsString(Args);
281 return;
282 }
283
Daniel Dunbarf4714872011-11-17 00:36:57 +0000284 // If we are building profile support, link that library in.
285 if (Args.hasArg(options::OPT_fprofile_arcs) ||
286 Args.hasArg(options::OPT_fprofile_generate) ||
287 Args.hasArg(options::OPT_fcreate_profile) ||
288 Args.hasArg(options::OPT_coverage)) {
289 // Select the appropriate runtime library for the target.
290 if (isTargetIPhoneOS()) {
291 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a");
292 } else {
293 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a");
294 }
295 }
296
Peter Collingbourne52ca70d2013-04-09 04:35:11 +0000297 SanitizerArgs Sanitize(*this, Args);
Alexey Samsonovbb1071c2012-11-06 15:09:03 +0000298
Alexey Samsonov75fcb192012-11-16 12:53:14 +0000299 // Add Ubsan runtime library, if required.
300 if (Sanitize.needsUbsanRt()) {
Alexey Samsonov2cb3d302013-01-21 08:45:02 +0000301 if (isTargetIPhoneOS()) {
Alexey Samsonov75fcb192012-11-16 12:53:14 +0000302 getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
303 << "-fsanitize=undefined";
304 } else {
Alexey Samsonov69b77d72012-11-21 14:17:42 +0000305 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ubsan_osx.a", true);
Alexey Samsonov75fcb192012-11-16 12:53:14 +0000306
307 // The Ubsan runtime library requires C++.
308 AddCXXStdlibLibArgs(Args, CmdArgs);
309 }
310 }
311
Kostya Serebryany7b5f1012011-12-06 19:18:44 +0000312 // Add ASAN runtime library, if required. Dynamic libraries and bundles
313 // should not be linked with the runtime library.
Alexey Samsonovbb1071c2012-11-06 15:09:03 +0000314 if (Sanitize.needsAsanRt()) {
Alexander Potapenko3656c612013-03-21 10:49:06 +0000315 if (isTargetIPhoneOS() && !isTargetIOSSimulator()) {
Daniel Dunbar94b54ea2011-12-01 23:40:18 +0000316 getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
Alexey Samsonovbb1071c2012-11-06 15:09:03 +0000317 << "-fsanitize=address";
Daniel Dunbar94b54ea2011-12-01 23:40:18 +0000318 } else {
Alexander Potapenko3656c612013-03-21 10:49:06 +0000319 if (Args.hasArg(options::OPT_dynamiclib) ||
320 Args.hasArg(options::OPT_bundle)) {
321 // Assume the binary will provide the ASan runtime.
322 } else {
323 AddLinkRuntimeLib(Args, CmdArgs,
324 "libclang_rt.asan_osx_dynamic.dylib", true);
325 // The ASAN runtime library requires C++.
326 AddCXXStdlibLibArgs(Args, CmdArgs);
327 }
Daniel Dunbar94b54ea2011-12-01 23:40:18 +0000328 }
329 }
330
Daniel Dunbareec99102010-01-22 03:38:14 +0000331 // Otherwise link libSystem, then the dynamic runtime library, and finally any
332 // target specific static runtime library.
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000333 CmdArgs.push_back("-lSystem");
Daniel Dunbareec99102010-01-22 03:38:14 +0000334
335 // Select the dynamic runtime library and the target specific static library.
Daniel Dunbar251ca6c2010-01-27 00:56:37 +0000336 if (isTargetIPhoneOS()) {
Daniel Dunbar87e945f2011-04-30 04:25:16 +0000337 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
338 // it never went into the SDK.
Bob Wilson163b1512011-10-07 17:54:41 +0000339 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
340 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator())
341 CmdArgs.push_back("-lgcc_s.1");
Daniel Dunbareec99102010-01-22 03:38:14 +0000342
Daniel Dunbar3cceec52011-04-18 23:48:36 +0000343 // We currently always need a static runtime library for iOS.
Eric Christopher3404fe72011-06-22 17:41:40 +0000344 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
Daniel Dunbareec99102010-01-22 03:38:14 +0000345 } else {
Daniel Dunbareec99102010-01-22 03:38:14 +0000346 // The dynamic runtime library was merged with libSystem for 10.6 and
347 // beyond; only 10.4 and 10.5 need an additional runtime library.
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000348 if (isMacosxVersionLT(10, 5))
Daniel Dunbareec99102010-01-22 03:38:14 +0000349 CmdArgs.push_back("-lgcc_s.10.4");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +0000350 else if (isMacosxVersionLT(10, 6))
Daniel Dunbareec99102010-01-22 03:38:14 +0000351 CmdArgs.push_back("-lgcc_s.10.5");
352
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000353 // For OS X, we thought we would only need a static runtime library when
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000354 // targeting 10.4, to provide versions of the static functions which were
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000355 // omitted from 10.4.dylib.
356 //
357 // Unfortunately, that turned out to not be true, because Darwin system
358 // headers can still use eprintf on i386, and it is not exported from
359 // libSystem. Therefore, we still must provide a runtime library just for
360 // the tiny tiny handful of projects that *might* use that symbol.
361 if (isMacosxVersionLT(10, 5)) {
Eric Christopher3404fe72011-06-22 17:41:40 +0000362 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000363 } else {
364 if (getTriple().getArch() == llvm::Triple::x86)
Eric Christopher3404fe72011-06-22 17:41:40 +0000365 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
366 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
Daniel Dunbar885b1db2010-09-22 00:03:52 +0000367 }
Daniel Dunbareec99102010-01-22 03:38:14 +0000368 }
Daniel Dunbar1d4612b2009-09-18 08:15:13 +0000369}
370
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000371void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000372 const OptTable &Opts = getDriver().getOpts();
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000373
Daniel Dunbar9101bc52012-08-17 18:43:50 +0000374 // Support allowing the SDKROOT environment variable used by xcrun and other
375 // Xcode tools to define the default sysroot, by making it the default for
376 // isysroot.
Chad Rosierd7dfd982012-12-19 23:41:50 +0000377 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
378 // Warn if the path does not exist.
Rafael Espindola40e6b302013-06-25 15:14:22 +0000379 if (!llvm::sys::fs::exists(A->getValue()))
Chad Rosierd7dfd982012-12-19 23:41:50 +0000380 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
381 } else {
Daniel Dunbar9101bc52012-08-17 18:43:50 +0000382 if (char *env = ::getenv("SDKROOT")) {
Daniel Dunbar32142542013-01-15 20:33:56 +0000383 // We only use this value as the default if it is an absolute path,
384 // exists, and it is not the root path.
385 if (llvm::sys::path::is_absolute(env) && llvm::sys::fs::exists(env) &&
386 StringRef(env) != "/") {
Daniel Dunbar9101bc52012-08-17 18:43:50 +0000387 Args.append(Args.MakeSeparateArg(
388 0, Opts.getOption(options::OPT_isysroot), env));
389 }
390 }
391 }
392
Daniel Dunbar26031372010-01-27 00:56:25 +0000393 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000394 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
395 Arg *iOSSimVersion = Args.getLastArg(
396 options::OPT_mios_simulator_version_min_EQ);
Eli Friedman983d8352012-01-11 02:41:15 +0000397
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000398 if (OSXVersion && (iOSVersion || iOSSimVersion)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000399 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarff8857a2009-04-10 20:11:50 +0000400 << OSXVersion->getAsString(Args)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000401 << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
402 iOSVersion = iOSSimVersion = 0;
403 } else if (iOSVersion && iOSSimVersion) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000404 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000405 << iOSVersion->getAsString(Args)
406 << iOSSimVersion->getAsString(Args);
407 iOSSimVersion = 0;
408 } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
Chad Rosiera4884972011-08-31 20:56:25 +0000409 // If no deployment target was specified on the command line, check for
Daniel Dunbar816bc312010-01-26 01:45:19 +0000410 // environment defines.
Chad Rosiera4884972011-08-31 20:56:25 +0000411 StringRef OSXTarget;
412 StringRef iOSTarget;
413 StringRef iOSSimTarget;
414 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
415 OSXTarget = env;
416 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
417 iOSTarget = env;
418 if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
419 iOSSimTarget = env;
Daniel Dunbarf36a06a2009-04-10 21:00:07 +0000420
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000421 // If no '-miphoneos-version-min' specified on the command line and
Chad Rosiera4884972011-08-31 20:56:25 +0000422 // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
Gabor Greif241cbe42012-04-18 10:59:08 +0000423 // based on -isysroot.
Chad Rosiera4884972011-08-31 20:56:25 +0000424 if (iOSTarget.empty()) {
425 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
426 StringRef first, second;
Richard Smith1d489cf2012-11-01 04:30:05 +0000427 StringRef isysroot = A->getValue();
Chad Rosiera4884972011-08-31 20:56:25 +0000428 llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
429 if (second != "")
430 iOSTarget = second.substr(0,3);
431 }
432 }
Daniel Dunbar816bc312010-01-26 01:45:19 +0000433
Chad Rosier4f8de272011-09-28 00:46:32 +0000434 // If no OSX or iOS target has been specified and we're compiling for armv7,
435 // go ahead as assume we're targeting iOS.
Chad Rosier49033202012-05-09 18:55:57 +0000436 if (OSXTarget.empty() && iOSTarget.empty() &&
Bob Wilson336bfa32012-09-29 23:52:50 +0000437 (getDarwinArchName(Args) == "armv7" ||
438 getDarwinArchName(Args) == "armv7s"))
Chad Rosier87ca5582012-05-09 18:09:58 +0000439 iOSTarget = iOSVersionMin;
Chad Rosier4f8de272011-09-28 00:46:32 +0000440
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000441 // Handle conflicting deployment targets
Daniel Dunbar39053672010-02-02 17:31:12 +0000442 //
443 // FIXME: Don't hardcode default here.
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000444
445 // Do not allow conflicts with the iOS simulator target.
Chad Rosiera4884972011-08-31 20:56:25 +0000446 if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000447 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000448 << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
Chad Rosiera4884972011-08-31 20:56:25 +0000449 << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000450 "IPHONEOS_DEPLOYMENT_TARGET");
451 }
452
453 // Allow conflicts among OSX and iOS for historical reasons, but choose the
454 // default platform.
Chad Rosiera4884972011-08-31 20:56:25 +0000455 if (!OSXTarget.empty() && !iOSTarget.empty()) {
Daniel Dunbar39053672010-02-02 17:31:12 +0000456 if (getTriple().getArch() == llvm::Triple::arm ||
457 getTriple().getArch() == llvm::Triple::thumb)
Chad Rosiera4884972011-08-31 20:56:25 +0000458 OSXTarget = "";
Daniel Dunbar39053672010-02-02 17:31:12 +0000459 else
Chad Rosiera4884972011-08-31 20:56:25 +0000460 iOSTarget = "";
Daniel Dunbar39053672010-02-02 17:31:12 +0000461 }
Daniel Dunbar1a3c1d92010-01-29 17:02:25 +0000462
Chad Rosiera4884972011-08-31 20:56:25 +0000463 if (!OSXTarget.empty()) {
Michael J. Spencere4151c52012-10-19 22:36:40 +0000464 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000465 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
466 Args.append(OSXVersion);
Chad Rosiera4884972011-08-31 20:56:25 +0000467 } else if (!iOSTarget.empty()) {
Michael J. Spencere4151c52012-10-19 22:36:40 +0000468 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000469 iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
470 Args.append(iOSVersion);
Chad Rosiera4884972011-08-31 20:56:25 +0000471 } else if (!iOSSimTarget.empty()) {
Michael J. Spencere4151c52012-10-19 22:36:40 +0000472 const Option O = Opts.getOption(
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000473 options::OPT_mios_simulator_version_min_EQ);
474 iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
475 Args.append(iOSSimVersion);
Daniel Dunbar816bc312010-01-26 01:45:19 +0000476 } else {
Daniel Dunbar2bb38d02010-07-15 16:18:06 +0000477 // Otherwise, assume we are targeting OS X.
Michael J. Spencere4151c52012-10-19 22:36:40 +0000478 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000479 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
480 Args.append(OSXVersion);
Daniel Dunbar30392de2009-09-04 18:35:21 +0000481 }
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000482 }
Mike Stump1eb44332009-09-09 15:08:12 +0000483
Daniel Dunbar3fd823b2011-04-30 04:20:40 +0000484 // Reject invalid architecture combinations.
485 if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
486 getTriple().getArch() != llvm::Triple::x86_64)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000487 getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
Daniel Dunbar3fd823b2011-04-30 04:20:40 +0000488 << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
489 }
490
Daniel Dunbar26031372010-01-27 00:56:25 +0000491 // Set the tool chain target information.
492 unsigned Major, Minor, Micro;
493 bool HadExtra;
494 if (OSXVersion) {
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000495 assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
Richard Smith1d489cf2012-11-01 04:30:05 +0000496 if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor,
Daniel Dunbar26031372010-01-27 00:56:25 +0000497 Micro, HadExtra) || HadExtra ||
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000498 Major != 10 || Minor >= 100 || Micro >= 100)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000499 getDriver().Diag(diag::err_drv_invalid_version_number)
Daniel Dunbar26031372010-01-27 00:56:25 +0000500 << OSXVersion->getAsString(Args);
501 } else {
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000502 const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
503 assert(Version && "Unknown target platform!");
Richard Smith1d489cf2012-11-01 04:30:05 +0000504 if (!Driver::GetReleaseVersion(Version->getValue(), Major, Minor,
Eli Friedman983d8352012-01-11 02:41:15 +0000505 Micro, HadExtra) || HadExtra ||
506 Major >= 10 || Minor >= 100 || Micro >= 100)
507 getDriver().Diag(diag::err_drv_invalid_version_number)
508 << Version->getAsString(Args);
Daniel Dunbar26031372010-01-27 00:56:25 +0000509 }
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000510
Daniel Dunbar5f5c37b2011-04-30 04:18:16 +0000511 bool IsIOSSim = bool(iOSSimVersion);
512
513 // In GCC, the simulator historically was treated as being OS X in some
514 // contexts, like determining the link logic, despite generally being called
515 // with an iOS deployment target. For compatibility, we detect the
516 // simulator as iOS + x86, and treat it differently in a few contexts.
517 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
518 getTriple().getArch() == llvm::Triple::x86_64))
519 IsIOSSim = true;
520
521 setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
Daniel Dunbarc0e665e2010-07-19 17:11:33 +0000522}
523
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000524void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000525 ArgStringList &CmdArgs) const {
526 CXXStdlibType Type = GetCXXStdlibType(Args);
527
528 switch (Type) {
529 case ToolChain::CST_Libcxx:
530 CmdArgs.push_back("-lc++");
531 break;
532
533 case ToolChain::CST_Libstdcxx: {
534 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
535 // it was previously found in the gcc lib dir. However, for all the Darwin
536 // platforms we care about it was -lstdc++.6, so we search for that
537 // explicitly if we can't see an obvious -lstdc++ candidate.
538
539 // Check in the sysroot first.
540 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000541 SmallString<128> P(A->getValue());
542 llvm::sys::path::append(P, "usr");
543 llvm::sys::path::append(P, "lib");
544 llvm::sys::path::append(P, "libstdc++.dylib");
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000545
Rafael Espindola40e6b302013-06-25 15:14:22 +0000546 if (!llvm::sys::fs::exists(P.str())) {
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000547 llvm::sys::path::remove_filename(P);
548 llvm::sys::path::append(P, "libstdc++.6.dylib");
Rafael Espindola40e6b302013-06-25 15:14:22 +0000549 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000550 CmdArgs.push_back(Args.MakeArgString(P.str()));
551 return;
552 }
553 }
554 }
555
556 // Otherwise, look in the root.
Bob Wilson5a5dcdc2011-11-11 07:47:04 +0000557 // FIXME: This should be removed someday when we don't have to care about
558 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
Rafael Espindola40e6b302013-06-25 15:14:22 +0000559 if (!llvm::sys::fs::exists("/usr/lib/libstdc++.dylib") &&
560 llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib")) {
Daniel Dunbarefe91ea2010-09-17 01:16:06 +0000561 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
562 return;
563 }
564
565 // Otherwise, let the linker search.
566 CmdArgs.push_back("-lstdc++");
567 break;
568 }
569 }
570}
571
Shantonu Sen7433fed2010-09-17 18:39:08 +0000572void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
573 ArgStringList &CmdArgs) const {
574
575 // For Darwin platforms, use the compiler-rt-based support library
576 // instead of the gcc-provided one (which is also incidentally
577 // only present in the gcc lib dir, which makes it hard to find).
578
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000579 SmallString<128> P(getDriver().ResourceDir);
580 llvm::sys::path::append(P, "lib");
581 llvm::sys::path::append(P, "darwin");
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000582
583 // Use the newer cc_kext for iOS ARM after 6.0.
584 if (!isTargetIPhoneOS() || isTargetIOSSimulator() ||
585 !isIPhoneOSVersionLT(6, 0)) {
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000586 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000587 } else {
Rafael Espindola7b6301f2013-06-26 02:13:00 +0000588 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios5.a");
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000589 }
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000590
Shantonu Sen7433fed2010-09-17 18:39:08 +0000591 // For now, allow missing resource libraries to support developers who may
592 // not have compiler-rt checked out or integrated into their build.
Rafael Espindola40e6b302013-06-25 15:14:22 +0000593 if (llvm::sys::fs::exists(P.str()))
Shantonu Sen7433fed2010-09-17 18:39:08 +0000594 CmdArgs.push_back(Args.MakeArgString(P.str()));
595}
596
Daniel Dunbarc0e665e2010-07-19 17:11:33 +0000597DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
598 const char *BoundArch) const {
599 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
600 const OptTable &Opts = getDriver().getOpts();
601
602 // FIXME: We really want to get out of the tool chain level argument
603 // translation business, as it makes the driver functionality much
604 // more opaque. For now, we follow gcc closely solely for the
605 // purpose of easily achieving feature parity & testability. Once we
606 // have something that works, we should reevaluate each translation
607 // and try to push it down into tool specific logic.
Daniel Dunbar26031372010-01-27 00:56:25 +0000608
Daniel Dunbar279c1db2010-06-11 22:00:26 +0000609 for (ArgList::const_iterator it = Args.begin(),
610 ie = Args.end(); it != ie; ++it) {
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000611 Arg *A = *it;
612
613 if (A->getOption().matches(options::OPT_Xarch__)) {
Daniel Dunbar2a45fa72011-06-21 00:20:17 +0000614 // Skip this argument unless the architecture matches either the toolchain
615 // triple arch, or the arch being bound.
Rafael Espindola64f7ad92012-10-07 04:44:33 +0000616 llvm::Triple::ArchType XarchArch =
Richard Smith1d489cf2012-11-01 04:30:05 +0000617 tools::darwin::getArchTypeForDarwinArchName(A->getValue(0));
Rafael Espindola64f7ad92012-10-07 04:44:33 +0000618 if (!(XarchArch == getArch() ||
619 (BoundArch && XarchArch ==
Rafael Espindolacfed8282012-10-31 18:51:07 +0000620 tools::darwin::getArchTypeForDarwinArchName(BoundArch))))
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000621 continue;
622
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000623 Arg *OriginalArg = A;
Richard Smith1d489cf2012-11-01 04:30:05 +0000624 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
Daniel Dunbar0e100312010-06-14 21:23:08 +0000625 unsigned Prev = Index;
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000626 Arg *XarchArg = Opts.ParseOneArg(Args, Index);
Mike Stump1eb44332009-09-09 15:08:12 +0000627
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000628 // If the argument parsing failed or more than one argument was
629 // consumed, the -Xarch_ argument's parameter tried to consume
630 // extra arguments. Emit an error and ignore.
631 //
632 // We also want to disallow any options which would alter the
633 // driver behavior; that isn't going to work in our model. We
634 // use isDriverOption() as an approximation, although things
635 // like -O4 are going to slip through.
Daniel Dunbar0e02f6e2011-04-21 17:41:34 +0000636 if (!XarchArg || Index > Prev + 1) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000637 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
Daniel Dunbar7e9293b2011-04-21 17:32:21 +0000638 << A->getAsString(Args);
639 continue;
Michael J. Spencer91e06da2012-10-19 22:37:06 +0000640 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000641 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000642 << A->getAsString(Args);
643 continue;
644 }
645
Daniel Dunbar478edc22009-03-29 22:29:05 +0000646 XarchArg->setBaseArg(A);
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000647 A = XarchArg;
Daniel Dunbar0e100312010-06-14 21:23:08 +0000648
649 DAL->AddSynthesizedArg(A);
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000650
651 // Linker input arguments require custom handling. The problem is that we
652 // have already constructed the phase actions, so we can not treat them as
653 // "input arguments".
Michael J. Spencer91e06da2012-10-19 22:37:06 +0000654 if (A->getOption().hasFlag(options::LinkerInput)) {
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000655 // Convert the argument into individual Zlinker_input_args.
656 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
657 DAL->AddSeparateArg(OriginalArg,
658 Opts.getOption(options::OPT_Zlinker_input),
Richard Smith1d489cf2012-11-01 04:30:05 +0000659 A->getValue(i));
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +0000660
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000661 }
662 continue;
663 }
Mike Stump1eb44332009-09-09 15:08:12 +0000664 }
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000665
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000666 // Sob. These is strictly gcc compatible for the time being. Apple
667 // gcc translates options twice, which means that self-expanding
668 // options add duplicates.
Daniel Dunbar9e1f9822009-11-19 04:14:53 +0000669 switch ((options::ID) A->getOption().getID()) {
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000670 default:
671 DAL->append(A);
672 break;
673
674 case options::OPT_mkernel:
675 case options::OPT_fapple_kext:
676 DAL->append(A);
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000677 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000678 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000679
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000680 case options::OPT_dependency_file:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000681 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
Richard Smith1d489cf2012-11-01 04:30:05 +0000682 A->getValue());
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000683 break;
684
685 case options::OPT_gfull:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000686 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
687 DAL->AddFlagArg(A,
688 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000689 break;
690
691 case options::OPT_gused:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000692 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
693 DAL->AddFlagArg(A,
694 Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000695 break;
696
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000697 case options::OPT_shared:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000698 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000699 break;
700
701 case options::OPT_fconstant_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000702 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000703 break;
704
705 case options::OPT_fno_constant_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000706 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000707 break;
708
709 case options::OPT_Wnonportable_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000710 DAL->AddFlagArg(A,
711 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000712 break;
713
714 case options::OPT_Wno_nonportable_cfstrings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000715 DAL->AddFlagArg(A,
716 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000717 break;
718
719 case options::OPT_fpascal_strings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000720 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000721 break;
722
723 case options::OPT_fno_pascal_strings:
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000724 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000725 break;
726 }
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000727 }
728
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000729 if (getTriple().getArch() == llvm::Triple::x86 ||
730 getTriple().getArch() == llvm::Triple::x86_64)
Daniel Dunbare4bdae72009-11-19 04:00:53 +0000731 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000732 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000733
734 // Add the arch options based on the particular spelling of -arch, to match
Chad Rosierc97e96a2012-04-27 14:58:16 +0000735 // how the driver driver works.
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000736 if (BoundArch) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000737 StringRef Name = BoundArch;
Michael J. Spencere4151c52012-10-19 22:36:40 +0000738 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
739 const Option MArch = Opts.getOption(options::OPT_march_EQ);
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000740
741 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
742 // which defines the list of which architectures we accept.
743 if (Name == "ppc")
744 ;
745 else if (Name == "ppc601")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000746 DAL->AddJoinedArg(0, MCpu, "601");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000747 else if (Name == "ppc603")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000748 DAL->AddJoinedArg(0, MCpu, "603");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000749 else if (Name == "ppc604")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000750 DAL->AddJoinedArg(0, MCpu, "604");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000751 else if (Name == "ppc604e")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000752 DAL->AddJoinedArg(0, MCpu, "604e");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000753 else if (Name == "ppc750")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000754 DAL->AddJoinedArg(0, MCpu, "750");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000755 else if (Name == "ppc7400")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000756 DAL->AddJoinedArg(0, MCpu, "7400");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000757 else if (Name == "ppc7450")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000758 DAL->AddJoinedArg(0, MCpu, "7450");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000759 else if (Name == "ppc970")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000760 DAL->AddJoinedArg(0, MCpu, "970");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000761
762 else if (Name == "ppc64")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000763 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000764
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000765 else if (Name == "i386")
766 ;
767 else if (Name == "i486")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000768 DAL->AddJoinedArg(0, MArch, "i486");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000769 else if (Name == "i586")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000770 DAL->AddJoinedArg(0, MArch, "i586");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000771 else if (Name == "i686")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000772 DAL->AddJoinedArg(0, MArch, "i686");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000773 else if (Name == "pentium")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000774 DAL->AddJoinedArg(0, MArch, "pentium");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000775 else if (Name == "pentium2")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000776 DAL->AddJoinedArg(0, MArch, "pentium2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000777 else if (Name == "pentpro")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000778 DAL->AddJoinedArg(0, MArch, "pentiumpro");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000779 else if (Name == "pentIIm3")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000780 DAL->AddJoinedArg(0, MArch, "pentium2");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000781
782 else if (Name == "x86_64")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000783 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000784
785 else if (Name == "arm")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000786 DAL->AddJoinedArg(0, MArch, "armv4t");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000787 else if (Name == "armv4t")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000788 DAL->AddJoinedArg(0, MArch, "armv4t");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000789 else if (Name == "armv5")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000790 DAL->AddJoinedArg(0, MArch, "armv5tej");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000791 else if (Name == "xscale")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000792 DAL->AddJoinedArg(0, MArch, "xscale");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000793 else if (Name == "armv6")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000794 DAL->AddJoinedArg(0, MArch, "armv6k");
Bob Wilson2503ebd2013-03-04 22:37:49 +0000795 else if (Name == "armv6m")
796 DAL->AddJoinedArg(0, MArch, "armv6m");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000797 else if (Name == "armv7")
Daniel Dunbar9d0863b2010-06-14 20:20:41 +0000798 DAL->AddJoinedArg(0, MArch, "armv7a");
Bob Wilson2503ebd2013-03-04 22:37:49 +0000799 else if (Name == "armv7em")
800 DAL->AddJoinedArg(0, MArch, "armv7em");
Bob Wilson336bfa32012-09-29 23:52:50 +0000801 else if (Name == "armv7f")
802 DAL->AddJoinedArg(0, MArch, "armv7f");
803 else if (Name == "armv7k")
804 DAL->AddJoinedArg(0, MArch, "armv7k");
Bob Wilson2503ebd2013-03-04 22:37:49 +0000805 else if (Name == "armv7m")
806 DAL->AddJoinedArg(0, MArch, "armv7m");
Bob Wilson336bfa32012-09-29 23:52:50 +0000807 else if (Name == "armv7s")
808 DAL->AddJoinedArg(0, MArch, "armv7s");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000809
810 else
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +0000811 llvm_unreachable("invalid Darwin arch");
Daniel Dunbar84ec96c2009-09-09 22:33:15 +0000812 }
Daniel Dunbarec069ed2009-03-25 06:58:31 +0000813
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000814 // Add an explicit version min argument for the deployment target. We do this
815 // after argument translation because -Xarch_ arguments may add a version min
816 // argument.
Chad Rosier8202fb82012-04-27 19:51:11 +0000817 if (BoundArch)
818 AddDeploymentTarget(*DAL);
Daniel Dunbar60baf0f2010-07-19 17:11:36 +0000819
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000820 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
821 // FIXME: It would be far better to avoid inserting those -static arguments,
822 // but we can't check the deployment target in the translation code until
823 // it is set here.
824 if (isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) {
825 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
826 Arg *A = *it;
827 ++it;
828 if (A->getOption().getID() != options::OPT_mkernel &&
829 A->getOption().getID() != options::OPT_fapple_kext)
830 continue;
831 assert(it != ie && "unexpected argument translation");
832 A = *it;
833 assert(A->getOption().getID() == options::OPT_static &&
834 "missing expected -static argument");
835 it = DAL->getArgs().erase(it);
836 }
837 }
838
Bob Wilson163b1512011-10-07 17:54:41 +0000839 // Validate the C++ standard library choice.
840 CXXStdlibType Type = GetCXXStdlibType(*DAL);
841 if (Type == ToolChain::CST_Libcxx) {
John McCall260611a2012-06-20 06:18:46 +0000842 // Check whether the target provides libc++.
843 StringRef where;
844
845 // Complain about targetting iOS < 5.0 in any way.
Bob Wilson377e5c12012-11-09 01:59:30 +0000846 if (isTargetIPhoneOS() && isIPhoneOSVersionLT(5, 0))
847 where = "iOS 5.0";
John McCall260611a2012-06-20 06:18:46 +0000848
849 if (where != StringRef()) {
Bob Wilson163b1512011-10-07 17:54:41 +0000850 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
John McCall260611a2012-06-20 06:18:46 +0000851 << where;
Bob Wilson163b1512011-10-07 17:54:41 +0000852 }
853 }
854
Daniel Dunbar4e7e9cf2009-03-25 06:12:34 +0000855 return DAL;
Mike Stump1eb44332009-09-09 15:08:12 +0000856}
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000857
Daniel Dunbarf3955282009-09-04 18:34:51 +0000858bool Darwin::IsUnwindTablesDefault() const {
Rafael Espindolaa4a809e2012-10-07 03:23:40 +0000859 return getArch() == llvm::Triple::x86_64;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000860}
861
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +0000862bool Darwin::UseDwarfDebugFlags() const {
863 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
864 return S[0] != '\0';
865 return false;
866}
867
Daniel Dunbarb2987d12010-02-10 18:49:11 +0000868bool Darwin::UseSjLjExceptions() const {
869 // Darwin uses SjLj exceptions on ARM.
870 return (getTriple().getArch() == llvm::Triple::arm ||
871 getTriple().getArch() == llvm::Triple::thumb);
872}
873
Chandler Carruth7ce816a2012-11-19 03:52:03 +0000874bool Darwin::isPICDefault() const {
875 return true;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000876}
877
Peter Collingbourne52ca70d2013-04-09 04:35:11 +0000878bool Darwin::isPIEDefault() const {
879 return false;
880}
881
Chandler Carruth7ce816a2012-11-19 03:52:03 +0000882bool Darwin::isPICDefaultForced() const {
883 return getArch() == llvm::Triple::x86_64;
Daniel Dunbar8eddb3f2009-03-20 00:57:52 +0000884}
885
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +0000886bool Darwin::SupportsProfiling() const {
887 // Profiling instrumentation is only supported on x86.
Rafael Espindola64f7ad92012-10-07 04:44:33 +0000888 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +0000889}
890
Daniel Dunbar43a9b322010-04-10 16:20:23 +0000891bool Darwin::SupportsObjCGC() const {
892 // Garbage collection is supported everywhere except on iPhone OS.
893 return !isTargetIPhoneOS();
894}
895
John McCall0a7dd782012-08-21 02:47:43 +0000896void Darwin::CheckObjCARC() const {
897 if (isTargetIPhoneOS() || !isMacosxVersionLT(10, 6))
898 return;
John McCall80fd37a2012-08-27 01:56:21 +0000899 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
Argyrios Kyrtzidis5840dd92012-02-29 03:43:52 +0000900}
901
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000902std::string
Chad Rosier61ab80a2011-09-20 20:44:06 +0000903Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args,
904 types::ID InputType) const {
905 return ComputeLLVMTriple(Args, InputType);
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000906}
907
Daniel Dunbar39176082009-03-20 00:20:03 +0000908/// Generic_GCC - A tool chain using the 'gcc' command to perform
909/// all subcommands; this relies on gcc translating the majority of
910/// command line options.
911
Chandler Carruth19347ed2011-11-06 23:39:34 +0000912/// \brief Parse a GCCVersion object out of a string of text.
913///
914/// This is the primary means of forming GCCVersion objects.
915/*static*/
916Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
917 const GCCVersion BadVersion = { VersionText.str(), -1, -1, -1, "" };
918 std::pair<StringRef, StringRef> First = VersionText.split('.');
919 std::pair<StringRef, StringRef> Second = First.second.split('.');
920
921 GCCVersion GoodVersion = { VersionText.str(), -1, -1, -1, "" };
922 if (First.first.getAsInteger(10, GoodVersion.Major) ||
923 GoodVersion.Major < 0)
924 return BadVersion;
925 if (Second.first.getAsInteger(10, GoodVersion.Minor) ||
926 GoodVersion.Minor < 0)
927 return BadVersion;
928
929 // First look for a number prefix and parse that if present. Otherwise just
930 // stash the entire patch string in the suffix, and leave the number
931 // unspecified. This covers versions strings such as:
932 // 4.4
933 // 4.4.0
934 // 4.4.x
935 // 4.4.2-rc4
936 // 4.4.x-patched
937 // And retains any patch number it finds.
938 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
939 if (!PatchText.empty()) {
Will Dietzca1ad502013-01-10 22:20:02 +0000940 if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
Chandler Carruth19347ed2011-11-06 23:39:34 +0000941 // Try to parse the number and any suffix.
942 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
943 GoodVersion.Patch < 0)
944 return BadVersion;
945 GoodVersion.PatchSuffix = PatchText.substr(EndNumber).str();
946 }
947 }
948
949 return GoodVersion;
950}
951
952/// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
953bool Generic_GCC::GCCVersion::operator<(const GCCVersion &RHS) const {
Chandler Carruthf1757652012-12-29 12:01:08 +0000954 if (Major != RHS.Major)
955 return Major < RHS.Major;
956 if (Minor != RHS.Minor)
957 return Minor < RHS.Minor;
958 if (Patch != RHS.Patch) {
959 // Note that versions without a specified patch sort higher than those with
960 // a patch.
961 if (RHS.Patch == -1)
962 return true;
963 if (Patch == -1)
964 return false;
Chandler Carruth19347ed2011-11-06 23:39:34 +0000965
Chandler Carruthf1757652012-12-29 12:01:08 +0000966 // Otherwise just sort on the patch itself.
967 return Patch < RHS.Patch;
968 }
969 if (PatchSuffix != RHS.PatchSuffix) {
970 // Sort empty suffixes higher.
971 if (RHS.PatchSuffix.empty())
972 return true;
973 if (PatchSuffix.empty())
Chandler Carruth5ba0c8e2012-12-29 13:00:47 +0000974 return false;
Chandler Carruth19347ed2011-11-06 23:39:34 +0000975
Chandler Carruthf1757652012-12-29 12:01:08 +0000976 // Provide a lexicographic sort to make this a total ordering.
977 return PatchSuffix < RHS.PatchSuffix;
978 }
979
980 // The versions are equal.
Chandler Carruth19347ed2011-11-06 23:39:34 +0000981 return false;
982}
983
Rafael Espindola0e659592012-02-19 01:38:32 +0000984static StringRef getGCCToolchainDir(const ArgList &Args) {
985 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
986 if (A)
Richard Smith1d489cf2012-11-01 04:30:05 +0000987 return A->getValue();
Rafael Espindola0e659592012-02-19 01:38:32 +0000988 return GCC_INSTALL_PREFIX;
989}
990
Chandler Carruth19347ed2011-11-06 23:39:34 +0000991/// \brief Construct a GCCInstallationDetector from the driver.
992///
993/// This performs all of the autodetection and sets up the various paths.
Gabor Greif0407a042012-04-17 11:16:26 +0000994/// Once constructed, a GCCInstallationDetector is essentially immutable.
Chandler Carruth1c6f04a2012-01-25 07:21:38 +0000995///
996/// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
997/// should instead pull the target out of the driver. This is currently
998/// necessary because the driver doesn't store the final version of the target
999/// triple.
1000Generic_GCC::GCCInstallationDetector::GCCInstallationDetector(
Chandler Carruthd79486a2013-06-22 11:35:51 +00001001 const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args)
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001002 : IsValid(false) {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001003 llvm::Triple BiarchVariantTriple =
1004 TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant()
Chandler Carruth9b338a72012-02-13 02:02:09 +00001005 : TargetTriple.get32BitArchVariant();
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001006 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
Chandler Carruth19347ed2011-11-06 23:39:34 +00001007 // The library directories which may contain GCC installations.
Chandler Carruthd79486a2013-06-22 11:35:51 +00001008 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
Chandler Carruth19347ed2011-11-06 23:39:34 +00001009 // The compatible GCC triples for this particular architecture.
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001010 SmallVector<StringRef, 10> CandidateTripleAliases;
Chandler Carruthd79486a2013-06-22 11:35:51 +00001011 SmallVector<StringRef, 10> CandidateBiarchTripleAliases;
1012 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1013 CandidateTripleAliases, CandidateBiarchLibDirs,
1014 CandidateBiarchTripleAliases);
Chandler Carruth19347ed2011-11-06 23:39:34 +00001015
1016 // Compute the set of prefixes for our search.
1017 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1018 D.PrefixDirs.end());
Rafael Espindola353300c2012-02-03 01:01:20 +00001019
Rafael Espindola0e659592012-02-19 01:38:32 +00001020 StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1021 if (GCCToolchainDir != "") {
1022 if (GCCToolchainDir.back() == '/')
1023 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
Rafael Espindola353300c2012-02-03 01:01:20 +00001024
Rafael Espindola0e659592012-02-19 01:38:32 +00001025 Prefixes.push_back(GCCToolchainDir);
Rafael Espindola353300c2012-02-03 01:01:20 +00001026 } else {
1027 Prefixes.push_back(D.SysRoot);
1028 Prefixes.push_back(D.SysRoot + "/usr");
1029 Prefixes.push_back(D.InstalledDir + "/..");
1030 }
Chandler Carruth19347ed2011-11-06 23:39:34 +00001031
1032 // Loop over the various components which exist and select the best GCC
1033 // installation available. GCC installs are ranked by version number.
1034 Version = GCCVersion::Parse("0.0.0");
1035 for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1036 if (!llvm::sys::fs::exists(Prefixes[i]))
1037 continue;
1038 for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1039 const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1040 if (!llvm::sys::fs::exists(LibDir))
1041 continue;
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001042 for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k)
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001043 ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1044 CandidateTripleAliases[k]);
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001045 }
Chandler Carruthd79486a2013-06-22 11:35:51 +00001046 for (unsigned j = 0, je = CandidateBiarchLibDirs.size(); j < je; ++j) {
1047 const std::string LibDir = Prefixes[i] + CandidateBiarchLibDirs[j].str();
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001048 if (!llvm::sys::fs::exists(LibDir))
1049 continue;
Chandler Carruthd79486a2013-06-22 11:35:51 +00001050 for (unsigned k = 0, ke = CandidateBiarchTripleAliases.size(); k < ke;
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001051 ++k)
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001052 ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
Chandler Carruthd79486a2013-06-22 11:35:51 +00001053 CandidateBiarchTripleAliases[k],
1054 /*NeedsBiarchSuffix=*/ true);
Chandler Carruth19347ed2011-11-06 23:39:34 +00001055 }
1056 }
1057}
1058
1059/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
Chandler Carruthd79486a2013-06-22 11:35:51 +00001060 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001061 SmallVectorImpl<StringRef> &LibDirs,
1062 SmallVectorImpl<StringRef> &TripleAliases,
Chandler Carruthd79486a2013-06-22 11:35:51 +00001063 SmallVectorImpl<StringRef> &BiarchLibDirs,
1064 SmallVectorImpl<StringRef> &BiarchTripleAliases) {
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001065 // Declare a bunch of static data sets that we'll select between below. These
1066 // are specifically designed to always refer to string literals to avoid any
1067 // lifetime or initialization issues.
Tim Northoverc264e162013-01-31 12:13:10 +00001068 static const char *const AArch64LibDirs[] = { "/lib" };
Chandler Carruthd79486a2013-06-22 11:35:51 +00001069 static const char *const AArch64Triples[] = { "aarch64-none-linux-gnu",
1070 "aarch64-linux-gnu" };
Tim Northoverc264e162013-01-31 12:13:10 +00001071
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001072 static const char *const ARMLibDirs[] = { "/lib" };
Chandler Carruthd79486a2013-06-22 11:35:51 +00001073 static const char *const ARMTriples[] = { "arm-linux-gnueabi",
1074 "arm-linux-androideabi" };
1075 static const char *const ARMHFTriples[] = { "arm-linux-gnueabihf",
1076 "armv7hl-redhat-linux-gnueabi" };
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001077
1078 static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1079 static const char *const X86_64Triples[] = {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001080 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-pc-linux-gnu",
1081 "x86_64-redhat-linux6E", "x86_64-redhat-linux", "x86_64-suse-linux",
1082 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", "x86_64-slackware-linux"
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001083 };
1084 static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1085 static const char *const X86Triples[] = {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001086 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", "i386-linux-gnu",
1087 "i386-redhat-linux6E", "i686-redhat-linux", "i586-redhat-linux",
1088 "i386-redhat-linux", "i586-suse-linux", "i486-slackware-linux",
Gabor Greif91720912012-05-15 11:21:03 +00001089 "i686-montavista-linux"
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001090 };
1091
1092 static const char *const MIPSLibDirs[] = { "/lib" };
1093 static const char *const MIPSTriples[] = { "mips-linux-gnu" };
1094 static const char *const MIPSELLibDirs[] = { "/lib" };
Chandler Carruthd79486a2013-06-22 11:35:51 +00001095 static const char *const MIPSELTriples[] = { "mipsel-linux-gnu",
1096 "mipsel-linux-android",
1097 "mips-linux-gnu" };
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001098
Simon Atanasyanb8c43812012-04-26 19:57:02 +00001099 static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" };
1100 static const char *const MIPS64Triples[] = { "mips64-linux-gnu" };
1101 static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" };
1102 static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" };
1103
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001104 static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1105 static const char *const PPCTriples[] = {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001106 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1107 "powerpc-suse-linux", "powerpc-montavista-linuxspe"
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001108 };
1109 static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
Chandler Carruthd79486a2013-06-22 11:35:51 +00001110 static const char *const PPC64Triples[] = { "powerpc64-linux-gnu",
1111 "powerpc64-unknown-linux-gnu",
1112 "powerpc64-suse-linux",
1113 "ppc64-redhat-linux" };
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001114
Ulrich Weigandb8409212013-05-06 16:26:41 +00001115 static const char *const SystemZLibDirs[] = { "/lib64", "/lib" };
1116 static const char *const SystemZTriples[] = {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001117 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1118 "s390x-suse-linux", "s390x-redhat-linux"
Ulrich Weigandb8409212013-05-06 16:26:41 +00001119 };
1120
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001121 switch (TargetTriple.getArch()) {
Tim Northoverc264e162013-01-31 12:13:10 +00001122 case llvm::Triple::aarch64:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001123 LibDirs.append(AArch64LibDirs,
1124 AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1125 TripleAliases.append(AArch64Triples,
1126 AArch64Triples + llvm::array_lengthof(AArch64Triples));
1127 BiarchLibDirs.append(AArch64LibDirs,
1128 AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1129 BiarchTripleAliases.append(
1130 AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
Tim Northoverc264e162013-01-31 12:13:10 +00001131 break;
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001132 case llvm::Triple::arm:
1133 case llvm::Triple::thumb:
Chandler Carruth19347ed2011-11-06 23:39:34 +00001134 LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
Jiangning Liuff104a12012-07-31 08:06:29 +00001135 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001136 TripleAliases.append(ARMHFTriples,
1137 ARMHFTriples + llvm::array_lengthof(ARMHFTriples));
Jiangning Liuff104a12012-07-31 08:06:29 +00001138 } else {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001139 TripleAliases.append(ARMTriples,
1140 ARMTriples + llvm::array_lengthof(ARMTriples));
Jiangning Liuff104a12012-07-31 08:06:29 +00001141 }
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001142 break;
1143 case llvm::Triple::x86_64:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001144 LibDirs.append(X86_64LibDirs,
1145 X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1146 TripleAliases.append(X86_64Triples,
1147 X86_64Triples + llvm::array_lengthof(X86_64Triples));
1148 BiarchLibDirs.append(X86LibDirs,
1149 X86LibDirs + llvm::array_lengthof(X86LibDirs));
1150 BiarchTripleAliases.append(X86Triples,
1151 X86Triples + llvm::array_lengthof(X86Triples));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001152 break;
1153 case llvm::Triple::x86:
Chandler Carruth19347ed2011-11-06 23:39:34 +00001154 LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
Chandler Carruthd79486a2013-06-22 11:35:51 +00001155 TripleAliases.append(X86Triples,
1156 X86Triples + llvm::array_lengthof(X86Triples));
1157 BiarchLibDirs.append(X86_64LibDirs,
1158 X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1159 BiarchTripleAliases.append(
1160 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001161 break;
1162 case llvm::Triple::mips:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001163 LibDirs.append(MIPSLibDirs,
1164 MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1165 TripleAliases.append(MIPSTriples,
1166 MIPSTriples + llvm::array_lengthof(MIPSTriples));
1167 BiarchLibDirs.append(MIPS64LibDirs,
1168 MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1169 BiarchTripleAliases.append(
1170 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001171 break;
1172 case llvm::Triple::mipsel:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001173 LibDirs.append(MIPSELLibDirs,
1174 MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1175 TripleAliases.append(MIPSELTriples,
1176 MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1177 BiarchLibDirs.append(
1178 MIPS64ELLibDirs,
1179 MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1180 BiarchTripleAliases.append(
1181 MIPS64ELTriples,
1182 MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
Simon Atanasyanb8c43812012-04-26 19:57:02 +00001183 break;
1184 case llvm::Triple::mips64:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001185 LibDirs.append(MIPS64LibDirs,
1186 MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1187 TripleAliases.append(MIPS64Triples,
1188 MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1189 BiarchLibDirs.append(MIPSLibDirs,
1190 MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1191 BiarchTripleAliases.append(MIPSTriples,
1192 MIPSTriples + llvm::array_lengthof(MIPSTriples));
Simon Atanasyanb8c43812012-04-26 19:57:02 +00001193 break;
1194 case llvm::Triple::mips64el:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001195 LibDirs.append(MIPS64ELLibDirs,
1196 MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
Simon Atanasyanb8c43812012-04-26 19:57:02 +00001197 TripleAliases.append(
Chandler Carruthd79486a2013-06-22 11:35:51 +00001198 MIPS64ELTriples,
1199 MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1200 BiarchLibDirs.append(MIPSELLibDirs,
1201 MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1202 BiarchTripleAliases.append(
1203 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001204 break;
1205 case llvm::Triple::ppc:
Chandler Carruth19347ed2011-11-06 23:39:34 +00001206 LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
Chandler Carruthd79486a2013-06-22 11:35:51 +00001207 TripleAliases.append(PPCTriples,
1208 PPCTriples + llvm::array_lengthof(PPCTriples));
1209 BiarchLibDirs.append(PPC64LibDirs,
1210 PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1211 BiarchTripleAliases.append(
1212 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001213 break;
1214 case llvm::Triple::ppc64:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001215 LibDirs.append(PPC64LibDirs,
1216 PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1217 TripleAliases.append(PPC64Triples,
1218 PPC64Triples + llvm::array_lengthof(PPC64Triples));
1219 BiarchLibDirs.append(PPCLibDirs,
1220 PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1221 BiarchTripleAliases.append(PPCTriples,
1222 PPCTriples + llvm::array_lengthof(PPCTriples));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001223 break;
Ulrich Weigandb8409212013-05-06 16:26:41 +00001224 case llvm::Triple::systemz:
Chandler Carruthd79486a2013-06-22 11:35:51 +00001225 LibDirs.append(SystemZLibDirs,
1226 SystemZLibDirs + llvm::array_lengthof(SystemZLibDirs));
1227 TripleAliases.append(SystemZTriples,
1228 SystemZTriples + llvm::array_lengthof(SystemZTriples));
Ulrich Weigandb8409212013-05-06 16:26:41 +00001229 break;
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001230
1231 default:
1232 // By default, just rely on the standard lib directories and the original
1233 // triple.
1234 break;
Chandler Carruth19347ed2011-11-06 23:39:34 +00001235 }
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001236
1237 // Always append the drivers target triple to the end, in case it doesn't
1238 // match any of our aliases.
1239 TripleAliases.push_back(TargetTriple.str());
1240
1241 // Also include the multiarch variant if it's different.
Chandler Carruthd79486a2013-06-22 11:35:51 +00001242 if (TargetTriple.str() != BiarchTriple.str())
1243 BiarchTripleAliases.push_back(BiarchTriple.str());
Chandler Carruth19347ed2011-11-06 23:39:34 +00001244}
1245
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001246static bool isSoftFloatABI(const ArgList &Args) {
1247 Arg *A = Args.getLastArg(options::OPT_msoft_float,
1248 options::OPT_mhard_float,
1249 options::OPT_mfloat_abi_EQ);
1250 if (!A) return false;
1251
1252 return A->getOption().matches(options::OPT_msoft_float) ||
1253 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1254 A->getValue() == StringRef("soft"));
1255}
1256
1257static bool isMipsArch(llvm::Triple::ArchType Arch) {
1258 return Arch == llvm::Triple::mips ||
1259 Arch == llvm::Triple::mipsel ||
1260 Arch == llvm::Triple::mips64 ||
1261 Arch == llvm::Triple::mips64el;
1262}
1263
1264static bool isMips16(const ArgList &Args) {
1265 Arg *A = Args.getLastArg(options::OPT_mips16,
1266 options::OPT_mno_mips16);
1267 return A && A->getOption().matches(options::OPT_mips16);
1268}
1269
1270static bool isMicroMips(const ArgList &Args) {
1271 Arg *A = Args.getLastArg(options::OPT_mmicromips,
1272 options::OPT_mno_micromips);
1273 return A && A->getOption().matches(options::OPT_mmicromips);
1274}
1275
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001276// FIXME: There is the same routine in the Tools.cpp.
1277static bool hasMipsN32ABIArg(const ArgList &Args) {
1278 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
Richard Smith1d489cf2012-11-01 04:30:05 +00001279 return A && (A->getValue() == StringRef("n32"));
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001280}
1281
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001282static void appendMipsTargetSuffix(std::string &Path,
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001283 llvm::Triple::ArchType TargetArch,
1284 const ArgList &Args) {
1285 if (isMips16(Args))
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001286 Path += "/mips16";
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001287 else if (isMicroMips(Args))
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001288 Path += "/micromips";
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001289
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001290 if (isSoftFloatABI(Args))
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001291 Path += "/soft-float";
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001292
1293 if (TargetArch == llvm::Triple::mipsel ||
1294 TargetArch == llvm::Triple::mips64el)
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001295 Path += "/el";
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001296}
1297
1298static StringRef getMipsTargetABISuffix(llvm::Triple::ArchType TargetArch,
1299 const ArgList &Args) {
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001300 if (TargetArch == llvm::Triple::mips64 ||
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001301 TargetArch == llvm::Triple::mips64el)
1302 return hasMipsN32ABIArg(Args) ? "/n32" : "/64";
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001303
1304 return "/32";
1305}
1306
Chandler Carruthd79486a2013-06-22 11:35:51 +00001307static bool findTargetBiarchSuffix(std::string &Suffix, StringRef Path,
1308 llvm::Triple::ArchType TargetArch,
1309 const ArgList &Args) {
1310 // FIXME: This routine was only intended to model bi-arch toolchains which
1311 // use -m32 and -m64 to swap between variants of a target. It shouldn't be
1312 // doing ABI-based builtin location for MIPS.
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001313 if (isMipsArch(TargetArch)) {
1314 StringRef ABISuffix = getMipsTargetABISuffix(TargetArch, Args);
1315
1316 // First build and check a complex path to crtbegin.o
1317 // depends on command line options (-mips16, -msoft-float, ...)
1318 // like mips-linux-gnu/4.7/mips16/soft-float/el/crtbegin.o
1319 appendMipsTargetSuffix(Suffix, TargetArch, Args);
1320
1321 if (TargetArch == llvm::Triple::mips64 ||
1322 TargetArch == llvm::Triple::mips64el)
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001323 Suffix += ABISuffix;
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001324
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001325 if (llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o"))
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001326 return true;
1327
1328 // Then fall back and probe a simple case like
1329 // mips-linux-gnu/4.7/32/crtbegin.o
1330 Suffix = ABISuffix;
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001331 return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001332 }
1333
1334 if (TargetArch == llvm::Triple::x86_64 ||
Ulrich Weigandb8409212013-05-06 16:26:41 +00001335 TargetArch == llvm::Triple::ppc64 ||
1336 TargetArch == llvm::Triple::systemz)
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001337 Suffix = "/64";
1338 else
1339 Suffix = "/32";
1340
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00001341 return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001342}
1343
Chandler Carruth19347ed2011-11-06 23:39:34 +00001344void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00001345 llvm::Triple::ArchType TargetArch, const ArgList &Args,
Chandler Carruthd79486a2013-06-22 11:35:51 +00001346 const std::string &LibDir, StringRef CandidateTriple,
1347 bool NeedsBiarchSuffix) {
Chandler Carruth19347ed2011-11-06 23:39:34 +00001348 // There are various different suffixes involving the triple we
1349 // check for. We also record what is necessary to walk from each back
1350 // up to the lib directory.
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001351 const std::string LibSuffixes[] = {
Chandler Carruth19347ed2011-11-06 23:39:34 +00001352 "/gcc/" + CandidateTriple.str(),
1353 "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1354
Hal Finkel02014b42012-09-18 22:25:07 +00001355 // The Freescale PPC SDK has the gcc libraries in
1356 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
1357 "/" + CandidateTriple.str(),
1358
Chandler Carruth19347ed2011-11-06 23:39:34 +00001359 // Ubuntu has a strange mis-matched pair of triples that this happens to
1360 // match.
1361 // FIXME: It may be worthwhile to generalize this and look for a second
1362 // triple.
Chandler Carruthd936d9d2011-11-09 03:46:20 +00001363 "/i386-linux-gnu/gcc/" + CandidateTriple.str()
Chandler Carruth19347ed2011-11-06 23:39:34 +00001364 };
Chandler Carruthd79486a2013-06-22 11:35:51 +00001365 const std::string InstallSuffixes[] = { "/../../..", "/../../../..", "/../..",
1366 "/../../../.." };
Chandler Carruth19347ed2011-11-06 23:39:34 +00001367 // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
Chandler Carruthd79486a2013-06-22 11:35:51 +00001368 const unsigned NumLibSuffixes =
1369 (llvm::array_lengthof(LibSuffixes) - (TargetArch != llvm::Triple::x86));
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001370 for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1371 StringRef LibSuffix = LibSuffixes[i];
Chandler Carruth19347ed2011-11-06 23:39:34 +00001372 llvm::error_code EC;
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001373 for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
Chandler Carruth19347ed2011-11-06 23:39:34 +00001374 !EC && LI != LE; LI = LI.increment(EC)) {
1375 StringRef VersionText = llvm::sys::path::filename(LI->path());
1376 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1377 static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1378 if (CandidateVersion < MinVersion)
1379 continue;
1380 if (CandidateVersion <= Version)
1381 continue;
Hal Finkel2e55df42011-12-08 05:50:03 +00001382
1383 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
Chandler Carruth5d84bb42012-01-24 19:21:42 +00001384 // in what would normally be GCCInstallPath and put the 64-bit
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001385 // libs in a subdirectory named 64. The simple logic we follow is that
1386 // *if* there is a subdirectory of the right name with crtbegin.o in it,
Chandler Carruthd79486a2013-06-22 11:35:51 +00001387 // we use that. If not, and if not a biarch triple alias, we look for
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001388 // crtbegin.o without the subdirectory.
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00001389
Chandler Carruthd79486a2013-06-22 11:35:51 +00001390 std::string BiarchSuffix;
1391 if (findTargetBiarchSuffix(BiarchSuffix, LI->path(), TargetArch, Args)) {
1392 GCCBiarchSuffix = BiarchSuffix;
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001393 } else {
Chandler Carruthd79486a2013-06-22 11:35:51 +00001394 if (NeedsBiarchSuffix ||
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001395 !llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1396 continue;
Chandler Carruthd79486a2013-06-22 11:35:51 +00001397 GCCBiarchSuffix.clear();
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001398 }
Chandler Carruth19347ed2011-11-06 23:39:34 +00001399
1400 Version = CandidateVersion;
Chandler Carruthfa5be912012-01-24 19:28:29 +00001401 GCCTriple.setTriple(CandidateTriple);
Chandler Carruth19347ed2011-11-06 23:39:34 +00001402 // FIXME: We hack together the directory name here instead of
1403 // using LI to ensure stable path separators across Windows and
1404 // Linux.
Chandler Carruth1c6f04a2012-01-25 07:21:38 +00001405 GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
Chandler Carruth5d84bb42012-01-24 19:21:42 +00001406 GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
Chandler Carruth19347ed2011-11-06 23:39:34 +00001407 IsValid = true;
1408 }
1409 }
1410}
1411
Rafael Espindola0e659592012-02-19 01:38:32 +00001412Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1413 const ArgList &Args)
Rafael Espindolaaf370e62013-03-18 18:10:27 +00001414 : ToolChain(D, Triple, Args), GCCInstallation(getDriver(), Triple, Args) {
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001415 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer86643b82011-03-01 22:50:47 +00001416 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001417 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbarc50b00d2009-03-23 16:15:50 +00001418}
1419
Daniel Dunbar39176082009-03-20 00:20:03 +00001420Generic_GCC::~Generic_GCC() {
Daniel Dunbar39176082009-03-20 00:20:03 +00001421}
1422
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001423Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
Rafael Espindola5b222052013-03-18 20:48:54 +00001424 switch (AC) {
Rafael Espindolaf3260562013-03-18 18:50:01 +00001425 case Action::PreprocessJobClass:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001426 if (!Preprocess)
1427 Preprocess.reset(new tools::gcc::Preprocess(*this));
1428 return Preprocess.get();
Rafael Espindolaf3260562013-03-18 18:50:01 +00001429 case Action::PrecompileJobClass:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001430 if (!Precompile)
1431 Precompile.reset(new tools::gcc::Precompile(*this));
1432 return Precompile.get();
Rafael Espindolaf3260562013-03-18 18:50:01 +00001433 case Action::CompileJobClass:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001434 if (!Compile)
1435 Compile.reset(new tools::gcc::Compile(*this));
1436 return Compile.get();
Rafael Espindolac0a55d12013-03-19 00:36:57 +00001437 default:
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001438 return ToolChain::getTool(AC);
Daniel Dunbar39176082009-03-20 00:20:03 +00001439 }
Daniel Dunbar39176082009-03-20 00:20:03 +00001440}
1441
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001442Tool *Generic_GCC::buildAssembler() const {
1443 return new tools::gcc::Assemble(*this);
1444}
1445
1446Tool *Generic_GCC::buildLinker() const {
1447 return new tools::gcc::Link(*this);
1448}
1449
Daniel Dunbar39176082009-03-20 00:20:03 +00001450bool Generic_GCC::IsUnwindTablesDefault() const {
Rafael Espindola6f009b62012-09-22 15:04:11 +00001451 return getArch() == llvm::Triple::x86_64;
Daniel Dunbar39176082009-03-20 00:20:03 +00001452}
1453
Chandler Carruth7ce816a2012-11-19 03:52:03 +00001454bool Generic_GCC::isPICDefault() const {
1455 return false;
Daniel Dunbar39176082009-03-20 00:20:03 +00001456}
1457
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00001458bool Generic_GCC::isPIEDefault() const {
1459 return false;
1460}
1461
Chandler Carruth7ce816a2012-11-19 03:52:03 +00001462bool Generic_GCC::isPICDefaultForced() const {
1463 return false;
Daniel Dunbar39176082009-03-20 00:20:03 +00001464}
Chandler Carruth7ce816a2012-11-19 03:52:03 +00001465
Tony Linthicum96319392011-12-12 21:14:55 +00001466/// Hexagon Toolchain
1467
Matthew Curtisb3489a02012-12-06 12:43:18 +00001468std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) {
1469
1470 // Locate the rest of the toolchain ...
1471 if (strlen(GCC_INSTALL_PREFIX))
1472 return std::string(GCC_INSTALL_PREFIX);
1473
1474 std::string InstallRelDir = InstalledDir + "/../../gnu";
1475 if (llvm::sys::fs::exists(InstallRelDir))
1476 return InstallRelDir;
1477
1478 std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
1479 if (llvm::sys::fs::exists(PrefixRelDir))
1480 return PrefixRelDir;
1481
1482 return InstallRelDir;
1483}
1484
Matthew Curtis5fdf3502012-12-06 15:46:07 +00001485static void GetHexagonLibraryPaths(
1486 const ArgList &Args,
1487 const std::string Ver,
1488 const std::string MarchString,
1489 const std::string &InstalledDir,
1490 ToolChain::path_list *LibPaths)
1491{
1492 bool buildingLib = Args.hasArg(options::OPT_shared);
1493
1494 //----------------------------------------------------------------------------
1495 // -L Args
1496 //----------------------------------------------------------------------------
1497 for (arg_iterator
1498 it = Args.filtered_begin(options::OPT_L),
1499 ie = Args.filtered_end();
1500 it != ie;
1501 ++it) {
1502 for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i)
1503 LibPaths->push_back((*it)->getValue(i));
1504 }
1505
1506 //----------------------------------------------------------------------------
1507 // Other standard paths
1508 //----------------------------------------------------------------------------
1509 const std::string MarchSuffix = "/" + MarchString;
1510 const std::string G0Suffix = "/G0";
1511 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
1512 const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/";
1513
1514 // lib/gcc/hexagon/...
1515 std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
1516 if (buildingLib) {
1517 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
1518 LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
1519 }
1520 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
1521 LibPaths->push_back(LibGCCHexagonDir + Ver);
1522
1523 // lib/gcc/...
1524 LibPaths->push_back(RootDir + "lib/gcc");
1525
1526 // hexagon/lib/...
1527 std::string HexagonLibDir = RootDir + "hexagon/lib";
1528 if (buildingLib) {
1529 LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
1530 LibPaths->push_back(HexagonLibDir + G0Suffix);
1531 }
1532 LibPaths->push_back(HexagonLibDir + MarchSuffix);
1533 LibPaths->push_back(HexagonLibDir);
1534}
1535
Matthew Curtisb3489a02012-12-06 12:43:18 +00001536Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
1537 const ArgList &Args)
1538 : Linux(D, Triple, Args) {
1539 const std::string InstalledDir(getDriver().getInstalledDir());
1540 const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir);
1541
1542 // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
1543 // program paths
1544 const std::string BinDir(GnuDir + "/bin");
1545 if (llvm::sys::fs::exists(BinDir))
1546 getProgramPaths().push_back(BinDir);
1547
1548 // Determine version of GCC libraries and headers to use.
1549 const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
1550 llvm::error_code ec;
1551 GCCVersion MaxVersion= GCCVersion::Parse("0.0.0");
1552 for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
1553 !ec && di != de; di = di.increment(ec)) {
1554 GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path()));
1555 if (MaxVersion < cv)
1556 MaxVersion = cv;
1557 }
1558 GCCLibAndIncVersion = MaxVersion;
Matthew Curtis5fdf3502012-12-06 15:46:07 +00001559
1560 ToolChain::path_list *LibPaths= &getFilePaths();
1561
1562 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
1563 // 'elf' OS type, so the Linux paths are not appropriate. When we actually
1564 // support 'linux' we'll need to fix this up
1565 LibPaths->clear();
1566
1567 GetHexagonLibraryPaths(
1568 Args,
1569 GetGCCLibAndIncVersion(),
1570 GetTargetCPU(Args),
1571 InstalledDir,
1572 LibPaths);
Tony Linthicum96319392011-12-12 21:14:55 +00001573}
1574
1575Hexagon_TC::~Hexagon_TC() {
Tony Linthicum96319392011-12-12 21:14:55 +00001576}
1577
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001578Tool *Hexagon_TC::buildAssembler() const {
1579 return new tools::hexagon::Assemble(*this);
1580}
1581
1582Tool *Hexagon_TC::buildLinker() const {
1583 return new tools::hexagon::Link(*this);
Tony Linthicum96319392011-12-12 21:14:55 +00001584}
1585
Matthew Curtisb3489a02012-12-06 12:43:18 +00001586void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1587 ArgStringList &CC1Args) const {
1588 const Driver &D = getDriver();
1589
1590 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
1591 DriverArgs.hasArg(options::OPT_nostdlibinc))
1592 return;
1593
Matthew Curtisb3489a02012-12-06 12:43:18 +00001594 std::string Ver(GetGCCLibAndIncVersion());
1595 std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir);
1596 std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
1597 addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
1598 addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
1599 addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
Tony Linthicum96319392011-12-12 21:14:55 +00001600}
1601
Matthew Curtisb3489a02012-12-06 12:43:18 +00001602void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1603 ArgStringList &CC1Args) const {
1604
1605 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1606 DriverArgs.hasArg(options::OPT_nostdincxx))
1607 return;
1608
1609 const Driver &D = getDriver();
1610 std::string Ver(GetGCCLibAndIncVersion());
Rafael Espindola7b6301f2013-06-26 02:13:00 +00001611 SmallString<128> IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir));
Matthew Curtisb3489a02012-12-06 12:43:18 +00001612
Rafael Espindola7b6301f2013-06-26 02:13:00 +00001613 llvm::sys::path::append(IncludeDir, "hexagon/include/c++/");
1614 llvm::sys::path::append(IncludeDir, Ver);
Matthew Curtisb3489a02012-12-06 12:43:18 +00001615 addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
Chandler Carruth7ce816a2012-11-19 03:52:03 +00001616}
Matthew Curtis67814152012-12-06 14:16:43 +00001617
Matthew Curtis5fdf3502012-12-06 15:46:07 +00001618ToolChain::CXXStdlibType
1619Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const {
1620 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1621 if (!A)
1622 return ToolChain::CST_Libstdcxx;
1623
1624 StringRef Value = A->getValue();
1625 if (Value != "libstdc++") {
1626 getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1627 << A->getAsString(Args);
1628 }
1629
1630 return ToolChain::CST_Libstdcxx;
1631}
1632
1633static Arg *GetLastHexagonArchArg(const ArgList &Args)
Matthew Curtis67814152012-12-06 14:16:43 +00001634{
1635 Arg *A = NULL;
1636
1637 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1638 it != ie; ++it) {
1639 if ((*it)->getOption().matches(options::OPT_march_EQ) ||
1640 (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1641 A = *it;
1642 A->claim();
1643 } else if ((*it)->getOption().matches(options::OPT_m_Joined)) {
1644 StringRef Value = (*it)->getValue(0);
1645 if (Value.startswith("v")) {
1646 A = *it;
1647 A->claim();
1648 }
1649 }
1650 }
1651 return A;
1652}
1653
1654StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
1655{
1656 // Select the default CPU (v4) if none was given or detection failed.
1657 Arg *A = GetLastHexagonArchArg (Args);
1658 if (A) {
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001659 StringRef WhichHexagon = A->getValue();
Matthew Curtis67814152012-12-06 14:16:43 +00001660 if (WhichHexagon.startswith("hexagon"))
1661 return WhichHexagon.substr(sizeof("hexagon") - 1);
1662 if (WhichHexagon != "")
1663 return WhichHexagon;
1664 }
1665
1666 return "v4";
1667}
Matthew Curtisb3489a02012-12-06 12:43:18 +00001668// End Hexagon
Daniel Dunbarf3cad362009-03-25 04:13:45 +00001669
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001670/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1671/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1672/// Currently does not support anything else but compilation.
1673
Rafael Espindolaaf370e62013-03-18 18:10:27 +00001674TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple,
1675 const ArgList &Args)
1676 : ToolChain(D, Triple, Args) {
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001677 // Path mangling to find libexec
1678 std::string Path(getDriver().Dir);
1679
1680 Path += "/../libexec";
1681 getProgramPaths().push_back(Path);
1682}
1683
1684TCEToolChain::~TCEToolChain() {
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001685}
1686
NAKAMURA Takumi304ed3f2011-06-03 03:49:51 +00001687bool TCEToolChain::IsMathErrnoDefault() const {
1688 return true;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001689}
1690
Chandler Carruth7ce816a2012-11-19 03:52:03 +00001691bool TCEToolChain::isPICDefault() const {
1692 return false;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001693}
1694
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00001695bool TCEToolChain::isPIEDefault() const {
1696 return false;
1697}
1698
Chandler Carruth7ce816a2012-11-19 03:52:03 +00001699bool TCEToolChain::isPICDefaultForced() const {
1700 return false;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00001701}
1702
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001703/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1704
Rafael Espindola0e659592012-02-19 01:38:32 +00001705OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1706 : Generic_ELF(D, Triple, Args) {
Daniel Dunbaree788e72009-12-21 18:54:17 +00001707 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001708 getFilePaths().push_back("/usr/lib");
1709}
1710
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001711Tool *OpenBSD::buildAssembler() const {
1712 return new tools::openbsd::Assemble(*this);
1713}
1714
1715Tool *OpenBSD::buildLinker() const {
1716 return new tools::openbsd::Link(*this);
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001717}
1718
Eli Friedman42f74f22012-08-08 23:57:20 +00001719/// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1720
1721Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1722 : Generic_ELF(D, Triple, Args) {
1723 getFilePaths().push_back(getDriver().Dir + "/../lib");
1724 getFilePaths().push_back("/usr/lib");
1725}
1726
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001727Tool *Bitrig::buildAssembler() const {
1728 return new tools::bitrig::Assemble(*this);
1729}
1730
1731Tool *Bitrig::buildLinker() const {
1732 return new tools::bitrig::Link(*this);
Eli Friedman42f74f22012-08-08 23:57:20 +00001733}
1734
1735void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1736 ArgStringList &CC1Args) const {
1737 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1738 DriverArgs.hasArg(options::OPT_nostdincxx))
1739 return;
1740
Chandler Carruth8e6881d2012-10-08 21:31:38 +00001741 switch (GetCXXStdlibType(DriverArgs)) {
1742 case ToolChain::CST_Libcxx:
1743 addSystemInclude(DriverArgs, CC1Args,
1744 getDriver().SysRoot + "/usr/include/c++/");
1745 break;
1746 case ToolChain::CST_Libstdcxx:
1747 addSystemInclude(DriverArgs, CC1Args,
1748 getDriver().SysRoot + "/usr/include/c++/stdc++");
1749 addSystemInclude(DriverArgs, CC1Args,
1750 getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
Eli Friedman42f74f22012-08-08 23:57:20 +00001751
Chandler Carruth8e6881d2012-10-08 21:31:38 +00001752 StringRef Triple = getTriple().str();
1753 if (Triple.startswith("amd64"))
1754 addSystemInclude(DriverArgs, CC1Args,
1755 getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
1756 Triple.substr(5));
1757 else
1758 addSystemInclude(DriverArgs, CC1Args,
1759 getDriver().SysRoot + "/usr/include/c++/stdc++/" +
1760 Triple);
1761 break;
1762 }
Eli Friedman42f74f22012-08-08 23:57:20 +00001763}
1764
1765void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1766 ArgStringList &CmdArgs) const {
Chandler Carruth8e6881d2012-10-08 21:31:38 +00001767 switch (GetCXXStdlibType(Args)) {
1768 case ToolChain::CST_Libcxx:
1769 CmdArgs.push_back("-lc++");
1770 CmdArgs.push_back("-lcxxrt");
1771 // Include supc++ to provide Unwind until provided by libcxx.
1772 CmdArgs.push_back("-lgcc");
1773 break;
1774 case ToolChain::CST_Libstdcxx:
1775 CmdArgs.push_back("-lstdc++");
1776 break;
1777 }
Eli Friedman42f74f22012-08-08 23:57:20 +00001778}
1779
Daniel Dunbar75358d22009-03-30 21:06:03 +00001780/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1781
Rafael Espindola0e659592012-02-19 01:38:32 +00001782FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1783 : Generic_ELF(D, Triple, Args) {
Daniel Dunbar214afe92010-08-02 05:43:59 +00001784
Chandler Carruth24248e32012-01-26 01:35:15 +00001785 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1786 // back to '/usr/lib' if it doesn't exist.
Chandler Carruth00646ba2012-01-25 11:24:24 +00001787 if ((Triple.getArch() == llvm::Triple::x86 ||
1788 Triple.getArch() == llvm::Triple::ppc) &&
Chandler Carruth24248e32012-01-26 01:35:15 +00001789 llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
Chandler Carruth00646ba2012-01-25 11:24:24 +00001790 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1791 else
1792 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
Daniel Dunbar75358d22009-03-30 21:06:03 +00001793}
1794
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001795Tool *FreeBSD::buildAssembler() const {
1796 return new tools::freebsd::Assemble(*this);
1797}
1798
1799Tool *FreeBSD::buildLinker() const {
1800 return new tools::freebsd::Link(*this);
Daniel Dunbar75358d22009-03-30 21:06:03 +00001801}
Daniel Dunbar11e1b402009-05-02 18:28:39 +00001802
Rafael Espindola27fa2362012-12-13 04:17:14 +00001803bool FreeBSD::UseSjLjExceptions() const {
1804 // FreeBSD uses SjLj exceptions on ARM oabi.
1805 switch (getTriple().getEnvironment()) {
1806 case llvm::Triple::GNUEABI:
1807 case llvm::Triple::EABI:
1808 return false;
1809
1810 default:
1811 return (getTriple().getArch() == llvm::Triple::arm ||
1812 getTriple().getArch() == llvm::Triple::thumb);
1813 }
1814}
1815
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001816/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1817
Rafael Espindola0e659592012-02-19 01:38:32 +00001818NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1819 : Generic_ELF(D, Triple, Args) {
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001820
Joerg Sonnenberger05e59302011-03-21 13:59:26 +00001821 if (getDriver().UseStdLib) {
Chandler Carruth32f88be2012-01-25 11:18:20 +00001822 // When targeting a 32-bit platform, try the special directory used on
1823 // 64-bit hosts, and only fall back to the main library directory if that
1824 // doesn't work.
1825 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
1826 // what all logic is needed to emulate the '=' prefix here.
Joerg Sonnenberger66de97f2012-01-26 21:58:37 +00001827 if (Triple.getArch() == llvm::Triple::x86)
Joerg Sonnenberger05e59302011-03-21 13:59:26 +00001828 getFilePaths().push_back("=/usr/lib/i386");
Chandler Carruth32f88be2012-01-25 11:18:20 +00001829
1830 getFilePaths().push_back("=/usr/lib");
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001831 }
1832}
1833
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001834Tool *NetBSD::buildAssembler() const {
1835 return new tools::netbsd::Assemble(*this);
1836}
1837
1838Tool *NetBSD::buildLinker() const {
1839 return new tools::netbsd::Link(*this);
Benjamin Kramer8e50a962011-02-02 18:59:27 +00001840}
1841
Joerg Sonnenbergera7efaf92013-04-30 01:21:43 +00001842ToolChain::CXXStdlibType
1843NetBSD::GetCXXStdlibType(const ArgList &Args) const {
1844 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
1845 StringRef Value = A->getValue();
1846 if (Value == "libstdc++")
1847 return ToolChain::CST_Libstdcxx;
1848 if (Value == "libc++")
1849 return ToolChain::CST_Libcxx;
1850
1851 getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1852 << A->getAsString(Args);
1853 }
1854
1855 return ToolChain::CST_Libstdcxx;
1856}
1857
1858void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1859 ArgStringList &CC1Args) const {
1860 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1861 DriverArgs.hasArg(options::OPT_nostdincxx))
1862 return;
1863
1864 switch (GetCXXStdlibType(DriverArgs)) {
1865 case ToolChain::CST_Libcxx:
1866 addSystemInclude(DriverArgs, CC1Args,
1867 getDriver().SysRoot + "/usr/include/c++/");
1868 break;
1869 case ToolChain::CST_Libstdcxx:
1870 addSystemInclude(DriverArgs, CC1Args,
1871 getDriver().SysRoot + "/usr/include/g++");
1872 addSystemInclude(DriverArgs, CC1Args,
1873 getDriver().SysRoot + "/usr/include/g++/backward");
1874 break;
1875 }
1876}
1877
Chris Lattner38e317d2010-07-07 16:01:42 +00001878/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1879
Rafael Espindola0e659592012-02-19 01:38:32 +00001880Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1881 : Generic_ELF(D, Triple, Args) {
Chris Lattner38e317d2010-07-07 16:01:42 +00001882 getFilePaths().push_back(getDriver().Dir + "/../lib");
1883 getFilePaths().push_back("/usr/lib");
Chris Lattner38e317d2010-07-07 16:01:42 +00001884}
1885
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001886Tool *Minix::buildAssembler() const {
1887 return new tools::minix::Assemble(*this);
1888}
1889
1890Tool *Minix::buildLinker() const {
1891 return new tools::minix::Link(*this);
Chris Lattner38e317d2010-07-07 16:01:42 +00001892}
1893
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001894/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1895
Rafael Espindola0e659592012-02-19 01:38:32 +00001896AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
1897 const ArgList &Args)
1898 : Generic_GCC(D, Triple, Args) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001899
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001900 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer86643b82011-03-01 22:50:47 +00001901 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbaredf29b02010-08-01 22:29:51 +00001902 getProgramPaths().push_back(getDriver().Dir);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001903
Daniel Dunbaree788e72009-12-21 18:54:17 +00001904 getFilePaths().push_back(getDriver().Dir + "/../lib");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001905 getFilePaths().push_back("/usr/lib");
1906 getFilePaths().push_back("/usr/sfw/lib");
1907 getFilePaths().push_back("/opt/gcc4/lib");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00001908 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001909
1910}
1911
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001912Tool *AuroraUX::buildAssembler() const {
1913 return new tools::auroraux::Assemble(*this);
1914}
1915
1916Tool *AuroraUX::buildLinker() const {
1917 return new tools::auroraux::Link(*this);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001918}
1919
David Chisnall31c46902012-02-15 13:39:01 +00001920/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
1921
Rafael Espindola0e659592012-02-19 01:38:32 +00001922Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
1923 const ArgList &Args)
1924 : Generic_GCC(D, Triple, Args) {
David Chisnall31c46902012-02-15 13:39:01 +00001925
1926 getProgramPaths().push_back(getDriver().getInstalledDir());
1927 if (getDriver().getInstalledDir() != getDriver().Dir)
1928 getProgramPaths().push_back(getDriver().Dir);
1929
1930 getFilePaths().push_back(getDriver().Dir + "/../lib");
1931 getFilePaths().push_back("/usr/lib");
1932}
1933
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00001934Tool *Solaris::buildAssembler() const {
1935 return new tools::solaris::Assemble(*this);
1936}
1937
1938Tool *Solaris::buildLinker() const {
1939 return new tools::solaris::Link(*this);
David Chisnall31c46902012-02-15 13:39:01 +00001940}
Edward O'Callaghane7925a02009-08-22 01:06:46 +00001941
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001942/// Distribution (very bare-bones at the moment).
Eli Friedman6b3454a2009-05-26 07:52:18 +00001943
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001944enum Distro {
Chandler Carruth3fd345a2011-02-25 06:39:53 +00001945 ArchLinux,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001946 DebianLenny,
1947 DebianSqueeze,
Eli Friedman0b200f62011-06-02 21:36:53 +00001948 DebianWheezy,
Sylvestre Ledrub1718522013-01-06 08:09:29 +00001949 DebianJessie,
Rafael Espindola0a84aee2010-11-11 02:07:13 +00001950 Exherbo,
Chris Lattnerd753b562011-05-22 05:36:06 +00001951 RHEL4,
1952 RHEL5,
1953 RHEL6,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001954 Fedora13,
1955 Fedora14,
Eric Christopher8f1cc072011-04-06 18:22:53 +00001956 Fedora15,
Benjamin Kramerafe55fb2012-02-06 15:33:06 +00001957 Fedora16,
Eric Christopher8f1cc072011-04-06 18:22:53 +00001958 FedoraRawhide,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001959 OpenSuse11_3,
David Chisnallde5c0482011-05-19 13:26:33 +00001960 OpenSuse11_4,
1961 OpenSuse12_1,
Douglas Gregor4e1b2922012-04-30 23:42:57 +00001962 OpenSuse12_2,
Douglas Gregor814638e2011-03-14 15:39:50 +00001963 UbuntuHardy,
1964 UbuntuIntrepid,
Rafael Espindola021aaa42010-11-10 05:00:22 +00001965 UbuntuJaunty,
Zhongxing Xu5ede8072010-11-15 09:01:52 +00001966 UbuntuKarmic,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001967 UbuntuLucid,
1968 UbuntuMaverick,
Ted Kremenek43ac2972011-04-05 22:04:27 +00001969 UbuntuNatty,
Benjamin Kramer25a857b2011-06-05 16:08:59 +00001970 UbuntuOneiric,
Benjamin Kramer668ecd92012-02-06 14:36:09 +00001971 UbuntuPrecise,
Rafael Espindolade39d172012-12-13 20:26:05 +00001972 UbuntuQuantal,
1973 UbuntuRaring,
Sylvestre Ledru1b034642013-06-13 11:52:27 +00001974 UbuntuSaucy,
Rafael Espindolac1da9812010-11-07 20:14:31 +00001975 UnknownDistro
1976};
1977
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001978static bool IsRedhat(enum Distro Distro) {
Benjamin Kramerafe55fb2012-02-06 15:33:06 +00001979 return (Distro >= Fedora13 && Distro <= FedoraRawhide) ||
1980 (Distro >= RHEL4 && Distro <= RHEL6);
Rafael Espindolac1da9812010-11-07 20:14:31 +00001981}
1982
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001983static bool IsOpenSuse(enum Distro Distro) {
Douglas Gregor4e1b2922012-04-30 23:42:57 +00001984 return Distro >= OpenSuse11_3 && Distro <= OpenSuse12_2;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001985}
1986
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001987static bool IsDebian(enum Distro Distro) {
Sylvestre Ledrub1718522013-01-06 08:09:29 +00001988 return Distro >= DebianLenny && Distro <= DebianJessie;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001989}
1990
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001991static bool IsUbuntu(enum Distro Distro) {
Sylvestre Ledru1b034642013-06-13 11:52:27 +00001992 return Distro >= UbuntuHardy && Distro <= UbuntuSaucy;
Rafael Espindolac1da9812010-11-07 20:14:31 +00001993}
1994
Thomas Schwinged52b4a92013-03-28 19:02:48 +00001995static Distro DetectDistro(llvm::Triple::ArchType Arch) {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00001996 OwningPtr<llvm::MemoryBuffer> File;
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00001997 if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001998 StringRef Data = File.get()->getBuffer();
1999 SmallVector<StringRef, 8> Lines;
Rafael Espindolac1da9812010-11-07 20:14:31 +00002000 Data.split(Lines, "\n");
Thomas Schwinged52b4a92013-03-28 19:02:48 +00002001 Distro Version = UnknownDistro;
Benjamin Kramer668ecd92012-02-06 14:36:09 +00002002 for (unsigned i = 0, s = Lines.size(); i != s; ++i)
2003 if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
Thomas Schwinged52b4a92013-03-28 19:02:48 +00002004 Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
Benjamin Kramer668ecd92012-02-06 14:36:09 +00002005 .Case("hardy", UbuntuHardy)
2006 .Case("intrepid", UbuntuIntrepid)
2007 .Case("jaunty", UbuntuJaunty)
2008 .Case("karmic", UbuntuKarmic)
2009 .Case("lucid", UbuntuLucid)
2010 .Case("maverick", UbuntuMaverick)
2011 .Case("natty", UbuntuNatty)
2012 .Case("oneiric", UbuntuOneiric)
2013 .Case("precise", UbuntuPrecise)
Rafael Espindolade39d172012-12-13 20:26:05 +00002014 .Case("quantal", UbuntuQuantal)
2015 .Case("raring", UbuntuRaring)
Sylvestre Ledru1b034642013-06-13 11:52:27 +00002016 .Case("saucy", UbuntuSaucy)
Benjamin Kramer668ecd92012-02-06 14:36:09 +00002017 .Default(UnknownDistro);
2018 return Version;
Rafael Espindolac1da9812010-11-07 20:14:31 +00002019 }
2020
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00002021 if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002022 StringRef Data = File.get()->getBuffer();
Benjamin Kramerafe55fb2012-02-06 15:33:06 +00002023 if (Data.startswith("Fedora release 16"))
2024 return Fedora16;
2025 else if (Data.startswith("Fedora release 15"))
Eric Christopher8f1cc072011-04-06 18:22:53 +00002026 return Fedora15;
2027 else if (Data.startswith("Fedora release 14"))
Rafael Espindolac1da9812010-11-07 20:14:31 +00002028 return Fedora14;
Eric Christopher8f1cc072011-04-06 18:22:53 +00002029 else if (Data.startswith("Fedora release 13"))
Rafael Espindolac1da9812010-11-07 20:14:31 +00002030 return Fedora13;
Eric Christopher8f1cc072011-04-06 18:22:53 +00002031 else if (Data.startswith("Fedora release") &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00002032 Data.find("Rawhide") != StringRef::npos)
Eric Christopher8f1cc072011-04-06 18:22:53 +00002033 return FedoraRawhide;
Chris Lattnerd753b562011-05-22 05:36:06 +00002034 else if (Data.startswith("Red Hat Enterprise Linux") &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00002035 Data.find("release 6") != StringRef::npos)
Chris Lattnerd753b562011-05-22 05:36:06 +00002036 return RHEL6;
Rafael Espindola5a640ef2011-06-03 15:23:24 +00002037 else if ((Data.startswith("Red Hat Enterprise Linux") ||
Eric Christopher4f4e2af2013-02-05 07:29:49 +00002038 Data.startswith("CentOS")) &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00002039 Data.find("release 5") != StringRef::npos)
Chris Lattnerd753b562011-05-22 05:36:06 +00002040 return RHEL5;
Rafael Espindola5a640ef2011-06-03 15:23:24 +00002041 else if ((Data.startswith("Red Hat Enterprise Linux") ||
Eric Christopher4f4e2af2013-02-05 07:29:49 +00002042 Data.startswith("CentOS")) &&
Chris Lattner5f9e2722011-07-23 10:55:15 +00002043 Data.find("release 4") != StringRef::npos)
Chris Lattnerd753b562011-05-22 05:36:06 +00002044 return RHEL4;
Rafael Espindolac1da9812010-11-07 20:14:31 +00002045 return UnknownDistro;
2046 }
2047
Michael J. Spencer4eeebc42010-12-16 03:28:14 +00002048 if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002049 StringRef Data = File.get()->getBuffer();
Rafael Espindolac1da9812010-11-07 20:14:31 +00002050 if (Data[0] == '5')
2051 return DebianLenny;
Rafael Espindola0e743b12011-12-28 18:17:14 +00002052 else if (Data.startswith("squeeze/sid") || Data[0] == '6')
Rafael Espindolac1da9812010-11-07 20:14:31 +00002053 return DebianSqueeze;
Rafael Espindola0e743b12011-12-28 18:17:14 +00002054 else if (Data.startswith("wheezy/sid") || Data[0] == '7')
Eli Friedman0b200f62011-06-02 21:36:53 +00002055 return DebianWheezy;
Sylvestre Ledrub1718522013-01-06 08:09:29 +00002056 else if (Data.startswith("jessie/sid") || Data[0] == '8')
2057 return DebianJessie;
Rafael Espindolac1da9812010-11-07 20:14:31 +00002058 return UnknownDistro;
2059 }
2060
Benjamin Kramerafe55fb2012-02-06 15:33:06 +00002061 if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File))
Thomas Schwinged52b4a92013-03-28 19:02:48 +00002062 return llvm::StringSwitch<Distro>(File.get()->getBuffer())
Benjamin Kramerafe55fb2012-02-06 15:33:06 +00002063 .StartsWith("openSUSE 11.3", OpenSuse11_3)
2064 .StartsWith("openSUSE 11.4", OpenSuse11_4)
2065 .StartsWith("openSUSE 12.1", OpenSuse12_1)
Douglas Gregor4e1b2922012-04-30 23:42:57 +00002066 .StartsWith("openSUSE 12.2", OpenSuse12_2)
Benjamin Kramerafe55fb2012-02-06 15:33:06 +00002067 .Default(UnknownDistro);
Rafael Espindolac1da9812010-11-07 20:14:31 +00002068
Rafael Espindola40e6b302013-06-25 15:14:22 +00002069 if (llvm::sys::fs::exists("/etc/exherbo-release"))
Rafael Espindola0a84aee2010-11-11 02:07:13 +00002070 return Exherbo;
2071
Rafael Espindola40e6b302013-06-25 15:14:22 +00002072 if (llvm::sys::fs::exists("/etc/arch-release"))
Chandler Carruth3fd345a2011-02-25 06:39:53 +00002073 return ArchLinux;
2074
Rafael Espindolac1da9812010-11-07 20:14:31 +00002075 return UnknownDistro;
2076}
2077
Chandler Carruthdeb73f82011-10-31 08:42:24 +00002078/// \brief Get our best guess at the multiarch triple for a target.
2079///
2080/// Debian-based systems are starting to use a multiarch setup where they use
2081/// a target-triple directory in the library and header search paths.
2082/// Unfortunately, this triple does not align with the vanilla target triple,
2083/// so we provide a rough mapping here.
2084static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
2085 StringRef SysRoot) {
2086 // For most architectures, just use whatever we have rather than trying to be
2087 // clever.
2088 switch (TargetTriple.getArch()) {
2089 default:
2090 return TargetTriple.str();
2091
2092 // We use the existence of '/lib/<triple>' as a directory to detect some
2093 // common linux triples that don't quite match the Clang triple for both
Chandler Carruth236e0b62011-10-31 09:06:40 +00002094 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
2095 // regardless of what the actual target triple is.
Chad Rosier0337efd2012-07-11 19:08:21 +00002096 case llvm::Triple::arm:
2097 case llvm::Triple::thumb:
Jiangning Liuff104a12012-07-31 08:06:29 +00002098 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2099 if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
2100 return "arm-linux-gnueabihf";
2101 } else {
2102 if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2103 return "arm-linux-gnueabi";
2104 }
Chad Rosier0337efd2012-07-11 19:08:21 +00002105 return TargetTriple.str();
Chandler Carruthdeb73f82011-10-31 08:42:24 +00002106 case llvm::Triple::x86:
Chandler Carruthdeb73f82011-10-31 08:42:24 +00002107 if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2108 return "i386-linux-gnu";
2109 return TargetTriple.str();
2110 case llvm::Triple::x86_64:
2111 if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2112 return "x86_64-linux-gnu";
Chandler Carruthdeb73f82011-10-31 08:42:24 +00002113 return TargetTriple.str();
Tim Northoverc264e162013-01-31 12:13:10 +00002114 case llvm::Triple::aarch64:
2115 if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2116 return "aarch64-linux-gnu";
Tim Northover162579a2013-06-13 22:54:55 +00002117 return TargetTriple.str();
Eli Friedman5bea4f62011-11-08 19:43:37 +00002118 case llvm::Triple::mips:
2119 if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2120 return "mips-linux-gnu";
2121 return TargetTriple.str();
2122 case llvm::Triple::mipsel:
2123 if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2124 return "mipsel-linux-gnu";
2125 return TargetTriple.str();
Chandler Carruth155c54c2012-02-26 09:03:21 +00002126 case llvm::Triple::ppc:
Sylvestre Ledrub7e86be2013-03-15 16:22:43 +00002127 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2128 return "powerpc-linux-gnuspe";
Chandler Carruth155c54c2012-02-26 09:03:21 +00002129 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2130 return "powerpc-linux-gnu";
2131 return TargetTriple.str();
2132 case llvm::Triple::ppc64:
2133 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2134 return "powerpc64-linux-gnu";
2135 return TargetTriple.str();
Chandler Carruthdeb73f82011-10-31 08:42:24 +00002136 }
2137}
2138
Chandler Carruth00646ba2012-01-25 11:24:24 +00002139static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2140 if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2141}
2142
Simon Atanasyanf8d9bd52012-10-03 17:46:38 +00002143static bool isMipsR2Arch(llvm::Triple::ArchType Arch,
2144 const ArgList &Args) {
2145 if (Arch != llvm::Triple::mips &&
2146 Arch != llvm::Triple::mipsel)
2147 return false;
2148
2149 Arg *A = Args.getLastArg(options::OPT_march_EQ,
2150 options::OPT_mcpu_EQ,
2151 options::OPT_mips_CPUs_Group);
2152
2153 if (!A)
2154 return false;
2155
2156 if (A->getOption().matches(options::OPT_mips_CPUs_Group))
2157 return A->getOption().matches(options::OPT_mips32r2);
2158
Richard Smith1d489cf2012-11-01 04:30:05 +00002159 return A->getValue() == StringRef("mips32r2");
Simon Atanasyanf8d9bd52012-10-03 17:46:38 +00002160}
2161
Simon Atanasyan7a918882012-09-14 11:27:24 +00002162static StringRef getMultilibDir(const llvm::Triple &Triple,
2163 const ArgList &Args) {
2164 if (!isMipsArch(Triple.getArch()))
2165 return Triple.isArch32Bit() ? "lib32" : "lib64";
2166
2167 // lib32 directory has a special meaning on MIPS targets.
2168 // It contains N32 ABI binaries. Use this folder if produce
2169 // code for N32 ABI only.
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00002170 if (hasMipsN32ABIArg(Args))
Simon Atanasyan7a918882012-09-14 11:27:24 +00002171 return "lib32";
2172
2173 return Triple.isArch32Bit() ? "lib" : "lib64";
2174}
2175
Rafael Espindola0e659592012-02-19 01:38:32 +00002176Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2177 : Generic_ELF(D, Triple, Args) {
Chandler Carruth89088792012-01-24 20:08:17 +00002178 llvm::Triple::ArchType Arch = Triple.getArch();
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002179 std::string SysRoot = computeSysRoot(Args);
Rafael Espindolac1da9812010-11-07 20:14:31 +00002180
Chandler Carruthef377442013-06-20 23:37:54 +00002181 // Cross-compiling binutils and GCC installations (vanilla and OpenSuse at
2182 // least) put various tools in a triple-prefixed directory off of the parent
2183 // of the GCC installation. We use the GCC triple here to ensure that we end
2184 // up with tools that support the same amount of cross compiling as the
2185 // detected GCC installation. For example, if we find a GCC installation
2186 // targeting x86_64, but it is a bi-arch GCC installation, it can also be
2187 // used to target i386.
2188 // FIXME: This seems unlikely to be Linux-specific.
Rafael Espindolaab784082011-09-01 16:25:49 +00002189 ToolChain::path_list &PPaths = getProgramPaths();
Chandler Carruthfa134592011-11-06 09:21:54 +00002190 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
Chandler Carruthfa5be912012-01-24 19:28:29 +00002191 GCCInstallation.getTriple().str() + "/bin").str());
Rafael Espindolaab784082011-09-01 16:25:49 +00002192
2193 Linker = GetProgramPath("ld");
Rafael Espindolac1da9812010-11-07 20:14:31 +00002194
Thomas Schwinged52b4a92013-03-28 19:02:48 +00002195 Distro Distro = DetectDistro(Arch);
Rafael Espindolac1da9812010-11-07 20:14:31 +00002196
Chris Lattner64a89172011-05-22 16:45:07 +00002197 if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
Rafael Espindola94c80222010-11-08 14:48:47 +00002198 ExtraOpts.push_back("-z");
2199 ExtraOpts.push_back("relro");
2200 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00002201
Douglas Gregorf0594d82011-03-06 19:11:49 +00002202 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00002203 ExtraOpts.push_back("-X");
2204
Logan Chien94a71422012-09-02 09:30:11 +00002205 const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002206 const bool IsMips = isMipsArch(Arch);
2207
2208 if (IsMips && !SysRoot.empty())
2209 ExtraOpts.push_back("--sysroot=" + SysRoot);
Evgeniy Stepanov704e7322012-01-13 09:30:38 +00002210
Chandler Carruthd4e6e7e2011-12-09 04:45:18 +00002211 // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2212 // and the MIPS ABI require .dynsym to be sorted in different ways.
2213 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2214 // ABI requires a mapping between the GOT and the symbol table.
Evgeniy Stepanov704e7322012-01-13 09:30:38 +00002215 // Android loader does not support .gnu.hash.
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002216 if (!IsMips && !IsAndroid) {
Benjamin Kramer668ecd92012-02-06 14:36:09 +00002217 if (IsRedhat(Distro) || IsOpenSuse(Distro) ||
2218 (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
Chandler Carruthd4e6e7e2011-12-09 04:45:18 +00002219 ExtraOpts.push_back("--hash-style=gnu");
2220
2221 if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
2222 Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2223 ExtraOpts.push_back("--hash-style=both");
2224 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00002225
Chris Lattnerd753b562011-05-22 05:36:06 +00002226 if (IsRedhat(Distro))
Rafael Espindolac1da9812010-11-07 20:14:31 +00002227 ExtraOpts.push_back("--no-add-needed");
2228
Eli Friedman0b200f62011-06-02 21:36:53 +00002229 if (Distro == DebianSqueeze || Distro == DebianWheezy ||
Sylvestre Ledrub1718522013-01-06 08:09:29 +00002230 Distro == DebianJessie || IsOpenSuse(Distro) ||
Rafael Espindola5a640ef2011-06-03 15:23:24 +00002231 (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
Benjamin Kramer668ecd92012-02-06 14:36:09 +00002232 (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
Rafael Espindolac1da9812010-11-07 20:14:31 +00002233 ExtraOpts.push_back("--build-id");
2234
Chris Lattner64a89172011-05-22 16:45:07 +00002235 if (IsOpenSuse(Distro))
Chandler Carruthf0b60ec2011-05-24 07:51:17 +00002236 ExtraOpts.push_back("--enable-new-dtags");
Chris Lattner64a89172011-05-22 16:45:07 +00002237
Chandler Carruthd2deee12011-10-03 05:28:29 +00002238 // The selection of paths to try here is designed to match the patterns which
2239 // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2240 // This was determined by running GCC in a fake filesystem, creating all
2241 // possible permutations of these directories, and seeing which ones it added
2242 // to the link paths.
2243 path_list &Paths = getFilePaths();
Chandler Carruth3fd345a2011-02-25 06:39:53 +00002244
Simon Atanasyan7a918882012-09-14 11:27:24 +00002245 const std::string Multilib = getMultilibDir(Triple, Args);
Chandler Carruthdeb73f82011-10-31 08:42:24 +00002246 const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
Chandler Carruthd2deee12011-10-03 05:28:29 +00002247
Chandler Carruthd1f73062011-11-06 23:09:05 +00002248 // Add the multilib suffixed paths where they are available.
2249 if (GCCInstallation.isValid()) {
Chandler Carruthfa5be912012-01-24 19:28:29 +00002250 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
Chandler Carruth89088792012-01-24 20:08:17 +00002251 const std::string &LibPath = GCCInstallation.getParentLibPath();
Simon Atanasyanf8d9bd52012-10-03 17:46:38 +00002252
2253 if (IsAndroid && isMipsR2Arch(Triple.getArch(), Args))
2254 addPathIfExists(GCCInstallation.getInstallPath() +
Chandler Carruthd79486a2013-06-22 11:35:51 +00002255 GCCInstallation.getBiarchSuffix() + "/mips-r2",
Simon Atanasyanf8d9bd52012-10-03 17:46:38 +00002256 Paths);
2257 else
2258 addPathIfExists((GCCInstallation.getInstallPath() +
Chandler Carruthd79486a2013-06-22 11:35:51 +00002259 GCCInstallation.getBiarchSuffix()),
Simon Atanasyanf8d9bd52012-10-03 17:46:38 +00002260 Paths);
Chandler Carruth9f314372012-04-06 16:32:06 +00002261
2262 // If the GCC installation we found is inside of the sysroot, we want to
2263 // prefer libraries installed in the parent prefix of the GCC installation.
2264 // It is important to *not* use these paths when the GCC installation is
Gabor Greif241cbe42012-04-18 10:59:08 +00002265 // outside of the system root as that can pick up unintended libraries.
Chandler Carruth9f314372012-04-06 16:32:06 +00002266 // This usually happens when there is an external cross compiler on the
2267 // host system, and a more minimal sysroot available that is the target of
2268 // the cross.
2269 if (StringRef(LibPath).startswith(SysRoot)) {
2270 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib,
2271 Paths);
2272 addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2273 addPathIfExists(LibPath + "/../" + Multilib, Paths);
2274 }
Evgeniy Stepanov1d01afe2012-09-03 09:05:50 +00002275 // On Android, libraries in the parent prefix of the GCC installation are
2276 // preferred to the ones under sysroot.
2277 if (IsAndroid) {
2278 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2279 }
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002280 // Sourcery CodeBench MIPS toolchain holds some libraries under
2281 // the parent prefix of the GCC installation.
2282 if (IsMips) {
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00002283 std::string Suffix;
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002284 appendMipsTargetSuffix(Suffix, Arch, Args);
2285 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" +
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00002286 Multilib + Suffix,
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002287 Paths);
2288 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00002289 }
Chandler Carruthd1f73062011-11-06 23:09:05 +00002290 addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2291 addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2292 addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2293 addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2294
Chandler Carruthd79486a2013-06-22 11:35:51 +00002295 // Try walking via the GCC triple path in case of biarch or multiarch GCC
Chandler Carruthd1f73062011-11-06 23:09:05 +00002296 // installations with strange symlinks.
2297 if (GCCInstallation.isValid())
Chandler Carruthfa5be912012-01-24 19:28:29 +00002298 addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
Chandler Carruthd1f73062011-11-06 23:09:05 +00002299 "/../../" + Multilib, Paths);
Rafael Espindolac7409a02011-06-03 15:39:42 +00002300
Chandler Carruth7a09d012011-10-16 10:54:30 +00002301 // Add the non-multilib suffixed paths (if potentially different).
Chandler Carruth048e6492011-10-03 18:16:54 +00002302 if (GCCInstallation.isValid()) {
2303 const std::string &LibPath = GCCInstallation.getParentLibPath();
Chandler Carruthfa5be912012-01-24 19:28:29 +00002304 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
Chandler Carruthd79486a2013-06-22 11:35:51 +00002305 if (!GCCInstallation.getBiarchSuffix().empty())
Chandler Carruth048e6492011-10-03 18:16:54 +00002306 addPathIfExists(GCCInstallation.getInstallPath(), Paths);
Chandler Carruth9f314372012-04-06 16:32:06 +00002307
2308 if (StringRef(LibPath).startswith(SysRoot)) {
2309 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2310 addPathIfExists(LibPath, Paths);
2311 }
Chandler Carruthd2deee12011-10-03 05:28:29 +00002312 }
Chandler Carruthfde8d142011-10-03 06:41:08 +00002313 addPathIfExists(SysRoot + "/lib", Paths);
2314 addPathIfExists(SysRoot + "/usr/lib", Paths);
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00002315
2316 IsPIEDefault = SanitizerArgs(*this, Args).hasZeroBaseShadow();
Rafael Espindolac1da9812010-11-07 20:14:31 +00002317}
2318
2319bool Linux::HasNativeLLVMSupport() const {
2320 return true;
Eli Friedman6b3454a2009-05-26 07:52:18 +00002321}
2322
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00002323Tool *Linux::buildLinker() const {
Thomas Schwinge577bb0a2013-03-28 19:04:25 +00002324 return new tools::gnutools::Link(*this);
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00002325}
2326
2327Tool *Linux::buildAssembler() const {
Thomas Schwinge577bb0a2013-03-28 19:04:25 +00002328 return new tools::gnutools::Assemble(*this);
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00002329}
2330
Chandler Carrutha6b25812012-11-21 23:40:23 +00002331void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2332 ArgStringList &CC1Args) const {
Rafael Espindola8af669f2012-06-19 01:26:10 +00002333 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
Chandler Carrutha6b25812012-11-21 23:40:23 +00002334 bool UseInitArrayDefault
2335 = V >= Generic_GCC::GCCVersion::Parse("4.7.0") ||
Tim Northoverc264e162013-01-31 12:13:10 +00002336 getTriple().getArch() == llvm::Triple::aarch64 ||
Chandler Carrutha6b25812012-11-21 23:40:23 +00002337 getTriple().getEnvironment() == llvm::Triple::Android;
2338 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2339 options::OPT_fno_use_init_array,
2340 UseInitArrayDefault))
Rafael Espindola8af669f2012-06-19 01:26:10 +00002341 CC1Args.push_back("-fuse-init-array");
2342}
2343
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002344std::string Linux::computeSysRoot(const ArgList &Args) const {
2345 if (!getDriver().SysRoot.empty())
2346 return getDriver().SysRoot;
2347
2348 if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
2349 return std::string();
2350
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00002351 std::string Path =
2352 (GCCInstallation.getInstallPath() +
2353 "/../../../../" + GCCInstallation.getTriple().str() + "/libc").str();
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002354 appendMipsTargetSuffix(Path, getTriple().getArch(), Args);
2355
Rafael Espindolaec2b1b92013-04-30 12:24:40 +00002356 return llvm::sys::fs::exists(Path) ? Path : "";
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002357}
2358
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002359void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2360 ArgStringList &CC1Args) const {
2361 const Driver &D = getDriver();
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002362 std::string SysRoot = computeSysRoot(DriverArgs);
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002363
2364 if (DriverArgs.hasArg(options::OPT_nostdinc))
2365 return;
2366
2367 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002368 addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002369
2370 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
Rafael Espindola7b6301f2013-06-26 02:13:00 +00002371 SmallString<128> P(D.ResourceDir);
2372 llvm::sys::path::append(P, "include");
Chandler Carruth07643082011-11-07 09:17:31 +00002373 addSystemInclude(DriverArgs, CC1Args, P.str());
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002374 }
2375
2376 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2377 return;
2378
2379 // Check for configure-time C include directories.
2380 StringRef CIncludeDirs(C_INCLUDE_DIRS);
2381 if (CIncludeDirs != "") {
2382 SmallVector<StringRef, 5> dirs;
2383 CIncludeDirs.split(dirs, ":");
2384 for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2385 I != E; ++I) {
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002386 StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : "";
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002387 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2388 }
2389 return;
2390 }
2391
2392 // Lacking those, try to detect the correct set of system includes for the
2393 // target triple.
2394
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002395 // Sourcery CodeBench and modern FSF Mips toolchains put extern C
2396 // system includes under three additional directories.
2397 if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) {
Chandler Carruthd79486a2013-06-22 11:35:51 +00002398 addExternCSystemIncludeIfExists(
2399 DriverArgs, CC1Args, GCCInstallation.getInstallPath() + "/include");
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002400
Chandler Carruthd79486a2013-06-22 11:35:51 +00002401 addExternCSystemIncludeIfExists(
2402 DriverArgs, CC1Args,
2403 GCCInstallation.getInstallPath() + "/../../../../" +
2404 GCCInstallation.getTriple().str() + "/libc/usr/include");
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002405 }
2406
Chandler Carrutha4630892011-11-06 08:21:07 +00002407 // Implement generic Debian multiarch support.
2408 const StringRef X86_64MultiarchIncludeDirs[] = {
2409 "/usr/include/x86_64-linux-gnu",
2410
2411 // FIXME: These are older forms of multiarch. It's not clear that they're
2412 // in use in any released version of Debian, so we should consider
2413 // removing them.
Chandler Carruthd79486a2013-06-22 11:35:51 +00002414 "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"
Chandler Carrutha4630892011-11-06 08:21:07 +00002415 };
2416 const StringRef X86MultiarchIncludeDirs[] = {
2417 "/usr/include/i386-linux-gnu",
2418
2419 // FIXME: These are older forms of multiarch. It's not clear that they're
2420 // in use in any released version of Debian, so we should consider
2421 // removing them.
Chandler Carruthd79486a2013-06-22 11:35:51 +00002422 "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
Chandler Carrutha4630892011-11-06 08:21:07 +00002423 "/usr/include/i486-linux-gnu"
2424 };
Tim Northoverc264e162013-01-31 12:13:10 +00002425 const StringRef AArch64MultiarchIncludeDirs[] = {
2426 "/usr/include/aarch64-linux-gnu"
2427 };
Chandler Carrutha4630892011-11-06 08:21:07 +00002428 const StringRef ARMMultiarchIncludeDirs[] = {
2429 "/usr/include/arm-linux-gnueabi"
2430 };
Jiangning Liuff104a12012-07-31 08:06:29 +00002431 const StringRef ARMHFMultiarchIncludeDirs[] = {
2432 "/usr/include/arm-linux-gnueabihf"
2433 };
Eli Friedmand7df7852011-11-11 03:05:19 +00002434 const StringRef MIPSMultiarchIncludeDirs[] = {
2435 "/usr/include/mips-linux-gnu"
2436 };
2437 const StringRef MIPSELMultiarchIncludeDirs[] = {
2438 "/usr/include/mipsel-linux-gnu"
2439 };
Chandler Carruth079d2bb2012-02-26 09:21:43 +00002440 const StringRef PPCMultiarchIncludeDirs[] = {
2441 "/usr/include/powerpc-linux-gnu"
2442 };
2443 const StringRef PPC64MultiarchIncludeDirs[] = {
2444 "/usr/include/powerpc64-linux-gnu"
2445 };
Chandler Carrutha4630892011-11-06 08:21:07 +00002446 ArrayRef<StringRef> MultiarchIncludeDirs;
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002447 if (getTriple().getArch() == llvm::Triple::x86_64) {
Chandler Carrutha4630892011-11-06 08:21:07 +00002448 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002449 } else if (getTriple().getArch() == llvm::Triple::x86) {
Chandler Carrutha4630892011-11-06 08:21:07 +00002450 MultiarchIncludeDirs = X86MultiarchIncludeDirs;
Tim Northoverc264e162013-01-31 12:13:10 +00002451 } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2452 MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002453 } else if (getTriple().getArch() == llvm::Triple::arm) {
Jiangning Liuff104a12012-07-31 08:06:29 +00002454 if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2455 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2456 else
2457 MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
Eli Friedmand7df7852011-11-11 03:05:19 +00002458 } else if (getTriple().getArch() == llvm::Triple::mips) {
2459 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2460 } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2461 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
Chandler Carruth079d2bb2012-02-26 09:21:43 +00002462 } else if (getTriple().getArch() == llvm::Triple::ppc) {
2463 MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2464 } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2465 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
Chandler Carrutha4630892011-11-06 08:21:07 +00002466 }
2467 for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2468 E = MultiarchIncludeDirs.end();
2469 I != E; ++I) {
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002470 if (llvm::sys::fs::exists(SysRoot + *I)) {
2471 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I);
Chandler Carrutha4630892011-11-06 08:21:07 +00002472 break;
2473 }
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002474 }
2475
2476 if (getTriple().getOS() == llvm::Triple::RTEMS)
2477 return;
2478
Chandler Carruthc44bc2d2011-11-08 17:19:47 +00002479 // Add an include of '/include' directly. This isn't provided by default by
2480 // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2481 // add even when Clang is acting as-if it were a system compiler.
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002482 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
Chandler Carruthc44bc2d2011-11-08 17:19:47 +00002483
Simon Atanasyan8e8e95c2013-04-20 08:15:03 +00002484 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002485}
2486
Dmitri Gribenkof2e7c352013-03-06 17:14:05 +00002487/// \brief Helper to add the three variant paths for a libstdc++ installation.
Chandler Carruth79cbbdc2011-12-17 23:10:01 +00002488/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2489 const ArgList &DriverArgs,
2490 ArgStringList &CC1Args) {
Chandler Carruthabaa1d72011-11-06 10:31:01 +00002491 if (!llvm::sys::fs::exists(Base))
2492 return false;
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002493 addSystemInclude(DriverArgs, CC1Args, Base);
Chandler Carruthabaa1d72011-11-06 10:31:01 +00002494 addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002495 addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
Chandler Carruthabaa1d72011-11-06 10:31:01 +00002496 return true;
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002497}
2498
Dmitri Gribenkof2e7c352013-03-06 17:14:05 +00002499/// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2500/// libstdc++ installation.
2501/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2502 Twine TargetArchDir,
2503 Twine MultiLibSuffix,
2504 const ArgList &DriverArgs,
2505 ArgStringList &CC1Args) {
2506 if (!addLibStdCXXIncludePaths(Base+Suffix, TargetArchDir + MultiLibSuffix,
2507 DriverArgs, CC1Args))
2508 return false;
2509
2510 addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2511 + MultiLibSuffix);
2512 return true;
2513}
2514
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002515void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2516 ArgStringList &CC1Args) const {
2517 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2518 DriverArgs.hasArg(options::OPT_nostdincxx))
2519 return;
2520
Chandler Carrutheb35ffc2011-11-07 09:01:17 +00002521 // Check if libc++ has been enabled and provide its include paths if so.
2522 if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2523 // libc++ is always installed at a fixed path on Linux currently.
2524 addSystemInclude(DriverArgs, CC1Args,
2525 getDriver().SysRoot + "/usr/include/c++/v1");
2526 return;
2527 }
2528
Chandler Carruthfc52f752012-01-25 08:04:13 +00002529 // We need a detected GCC installation on Linux to provide libstdc++'s
2530 // headers. We handled the libc++ case above.
2531 if (!GCCInstallation.isValid())
2532 return;
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002533
Chandler Carruthabaa1d72011-11-06 10:31:01 +00002534 // By default, look for the C++ headers in an include directory adjacent to
2535 // the lib directory of the GCC installation. Note that this is expect to be
2536 // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2537 StringRef LibDir = GCCInstallation.getParentLibPath();
2538 StringRef InstallDir = GCCInstallation.getInstallPath();
Rafael Espindola8af669f2012-06-19 01:26:10 +00002539 StringRef Version = GCCInstallation.getVersion().Text;
Evgeniy Stepanov1d01afe2012-09-03 09:05:50 +00002540 StringRef TripleStr = GCCInstallation.getTriple().str();
2541
Chandler Carruthd79486a2013-06-22 11:35:51 +00002542 if (addLibStdCXXIncludePaths(
2543 LibDir.str() + "/../include", "/c++/" + Version.str(), TripleStr,
2544 GCCInstallation.getBiarchSuffix(), DriverArgs, CC1Args))
Dmitri Gribenkof2e7c352013-03-06 17:14:05 +00002545 return;
2546
Evgeniy Stepanov1d01afe2012-09-03 09:05:50 +00002547 const std::string IncludePathCandidates[] = {
Chandler Carruthabaa1d72011-11-06 10:31:01 +00002548 // Gentoo is weird and places its headers inside the GCC install, so if the
2549 // first attempt to find the headers fails, try this pattern.
Evgeniy Stepanov1d01afe2012-09-03 09:05:50 +00002550 InstallDir.str() + "/include/g++-v4",
2551 // Android standalone toolchain has C++ headers in yet another place.
2552 LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.str(),
Hal Finkel02014b42012-09-18 22:25:07 +00002553 // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2554 // without a subdirectory corresponding to the gcc version.
2555 LibDir.str() + "/../include/c++",
Evgeniy Stepanov1d01afe2012-09-03 09:05:50 +00002556 };
2557
2558 for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
Chandler Carruthd79486a2013-06-22 11:35:51 +00002559 if (addLibStdCXXIncludePaths(
2560 IncludePathCandidates[i],
2561 (TripleStr + GCCInstallation.getBiarchSuffix()), DriverArgs,
2562 CC1Args))
Evgeniy Stepanov1d01afe2012-09-03 09:05:50 +00002563 break;
Chandler Carruthabaa1d72011-11-06 10:31:01 +00002564 }
Chandler Carruth7d7e9f92011-11-05 20:17:13 +00002565}
2566
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00002567bool Linux::isPIEDefault() const {
2568 return IsPIEDefault;
2569}
2570
Daniel Dunbar11e1b402009-05-02 18:28:39 +00002571/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2572
Rafael Espindola0e659592012-02-19 01:38:32 +00002573DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2574 : Generic_ELF(D, Triple, Args) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00002575
2576 // Path mangling to find libexec
Daniel Dunbaredf29b02010-08-01 22:29:51 +00002577 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer86643b82011-03-01 22:50:47 +00002578 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbaredf29b02010-08-01 22:29:51 +00002579 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00002580
Daniel Dunbaree788e72009-12-21 18:54:17 +00002581 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00002582 getFilePaths().push_back("/usr/lib");
John McCall8cfb7202013-04-11 22:55:55 +00002583 if (llvm::sys::fs::exists("/usr/lib/gcc47"))
2584 getFilePaths().push_back("/usr/lib/gcc47");
2585 else
2586 getFilePaths().push_back("/usr/lib/gcc44");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00002587}
2588
Rafael Espindolaf48b93c2013-03-20 03:05:54 +00002589Tool *DragonFly::buildAssembler() const {
2590 return new tools::dragonfly::Assemble(*this);
2591}
2592
2593Tool *DragonFly::buildLinker() const {
2594 return new tools::dragonfly::Link(*this);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00002595}