blob: e18656cb3df342124bdcb584569d8deaa694fbe4 [file] [log] [blame]
Hans Wennborgdcfba332015-10-06 23:40:43 +00001//===--- ToolChains.cpp - ToolChain Implementations -------------*- C++ -*-===//
Daniel Dunbar59e5e882009-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 Carruth3a022472012-12-04 09:13:33 +000011#include "clang/Basic/ObjCRuntime.h"
12#include "clang/Basic/Version.h"
Benjamin Kramerd45b2052015-10-07 15:48:01 +000013#include "clang/Basic/VirtualFileSystem.h"
Alp Toker1d257e12014-06-04 03:28:55 +000014#include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
Daniel Dunbar6232d342010-05-20 21:48:38 +000015#include "clang/Driver/Compilation.h"
Daniel Dunbar76ce7412009-03-23 16:15:50 +000016#include "clang/Driver/Driver.h"
Daniel Dunbaraabb0b12009-03-25 06:12:34 +000017#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000018#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000019#include "clang/Driver/SanitizerArgs.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000020#include "llvm/ADT/STLExtras.h"
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +000021#include "llvm/ADT/SmallString.h"
Daniel Dunbar76ce7412009-03-23 16:15:50 +000022#include "llvm/ADT/StringExtras.h"
Bob Wilson997a97f2011-10-07 00:37:57 +000023#include "llvm/ADT/StringSwitch.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000024#include "llvm/Option/Arg.h"
25#include "llvm/Option/ArgList.h"
26#include "llvm/Option/OptTable.h"
27#include "llvm/Option/Option.h"
Xinliang David Li170cd102015-10-27 05:15:35 +000028#include "llvm/ProfileData/InstrProf.h"
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +000029#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000030#include "llvm/Support/FileSystem.h"
Rafael Espindolac8f008f2010-11-07 20:14:31 +000031#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000032#include "llvm/Support/Path.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000033#include "llvm/Support/Program.h"
Renato Golin33e1f822015-05-28 15:49:28 +000034#include "llvm/Support/TargetParser.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000035#include "llvm/Support/raw_ostream.h"
Daniel Dunbarb5023e92009-04-10 21:00:07 +000036#include <cstdlib> // ::getenv
Rafael Espindola8a8e5542014-06-12 17:19:42 +000037#include <system_error>
Daniel Dunbarb5023e92009-04-10 21:00:07 +000038
Daniel Dunbar59e5e882009-03-20 00:20:03 +000039using namespace clang::driver;
40using namespace clang::driver::toolchains;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000041using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000042using namespace llvm::opt;
Daniel Dunbar59e5e882009-03-20 00:20:03 +000043
Douglas Katzmana67e50c2015-06-26 15:47:46 +000044MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
45 : ToolChain(D, Triple, Args) {
Tim Northover15ff71d2014-05-22 13:12:14 +000046 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
47 getProgramPaths().push_back(getDriver().getInstalledDir());
48 if (getDriver().getInstalledDir() != getDriver().Dir)
49 getProgramPaths().push_back(getDriver().Dir);
Tim Northover157d9112014-01-16 08:48:16 +000050}
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +000051
Tim Northover157d9112014-01-16 08:48:16 +000052/// Darwin - Darwin tool chain for i386 and x86_64.
Alexey Samsonov905c8022015-06-18 21:46:05 +000053Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
54 : MachO(D, Triple, Args), TargetInitialized(false) {}
Daniel Dunbar6276f992009-09-18 08:15:13 +000055
Tim Northover157d9112014-01-16 08:48:16 +000056types::ID MachO::LookupTypeForExtension(const char *Ext) const {
Daniel Dunbarcc7df6c2010-08-02 05:43:56 +000057 types::ID Ty = types::lookupTypeForExtension(Ext);
58
59 // Darwin always preprocesses assembly files (unless -x is used explicitly).
60 if (Ty == types::TY_PP_Asm)
61 return types::TY_Asm;
62
63 return Ty;
64}
65
Douglas Katzmana67e50c2015-06-26 15:47:46 +000066bool MachO::HasNativeLLVMSupport() const { return true; }
Daniel Dunbar62123a12010-09-17 00:24:52 +000067
John McCall24fc0de2011-07-06 00:26:06 +000068/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
John McCall5fb5df92012-06-20 06:18:46 +000069ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
Tim Northover9c7e0352013-12-12 11:55:52 +000070 if (isTargetIOSBased())
John McCall5fb5df92012-06-20 06:18:46 +000071 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
Bob Wilson5ad5a952012-11-09 01:59:30 +000072 if (isNonFragile)
73 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
74 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
John McCall24fc0de2011-07-06 00:26:06 +000075}
76
John McCall7959fee2011-09-09 20:41:01 +000077/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
78bool Darwin::hasBlocksRuntime() const {
Tim Northover9c7e0352013-12-12 11:55:52 +000079 if (isTargetIOSBased())
John McCall7959fee2011-09-09 20:41:01 +000080 return !isIPhoneOSVersionLT(3, 2);
Tim Northover9c7e0352013-12-12 11:55:52 +000081 else {
Tim Northover157d9112014-01-16 08:48:16 +000082 assert(isTargetMacOS() && "unexpected darwin target");
83 return !isMacosxVersionLT(10, 6);
Tim Northover9c7e0352013-12-12 11:55:52 +000084 }
John McCall7959fee2011-09-09 20:41:01 +000085}
86
Renato Golin33e1f822015-05-28 15:49:28 +000087// This is just a MachO name translation routine and there's no
88// way to join this into ARMTargetParser without breaking all
89// other assumptions. Maybe MachO should consider standardising
90// their nomenclature.
91static const char *ArmMachOArchName(StringRef Arch) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000092 return llvm::StringSwitch<const char *>(Arch)
93 .Case("armv6k", "armv6")
94 .Case("armv6m", "armv6m")
95 .Case("armv5tej", "armv5")
96 .Case("xscale", "xscale")
97 .Case("armv4t", "armv4t")
98 .Case("armv7", "armv7")
99 .Cases("armv7a", "armv7-a", "armv7")
100 .Cases("armv7r", "armv7-r", "armv7")
101 .Cases("armv7em", "armv7e-m", "armv7em")
102 .Cases("armv7k", "armv7-k", "armv7k")
103 .Cases("armv7m", "armv7-m", "armv7m")
104 .Cases("armv7s", "armv7-s", "armv7s")
105 .Default(nullptr);
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000106}
107
Renato Golin33e1f822015-05-28 15:49:28 +0000108static const char *ArmMachOArchNameCPU(StringRef CPU) {
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000109 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
Renato Golin33e1f822015-05-28 15:49:28 +0000110 if (ArchKind == llvm::ARM::AK_INVALID)
111 return nullptr;
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000112 StringRef Arch = llvm::ARM::getArchName(ArchKind);
Renato Golin33e1f822015-05-28 15:49:28 +0000113
114 // FIXME: Make sure this MachO triple mangling is really necessary.
115 // ARMv5* normalises to ARMv5.
116 if (Arch.startswith("armv5"))
117 Arch = Arch.substr(0, 5);
118 // ARMv6*, except ARMv6M, normalises to ARMv6.
119 else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
120 Arch = Arch.substr(0, 5);
121 // ARMv7A normalises to ARMv7.
122 else if (Arch.endswith("v7a"))
123 Arch = Arch.substr(0, 5);
124 return Arch.data();
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000125}
126
Tim Northover9c7e0352013-12-12 11:55:52 +0000127static bool isSoftFloatABI(const ArgList &Args) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000128 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
Tim Northover9c7e0352013-12-12 11:55:52 +0000129 options::OPT_mfloat_abi_EQ);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000130 if (!A)
131 return false;
Rafael Auler3f7abf72014-09-29 21:50:34 +0000132
Tim Northover9c7e0352013-12-12 11:55:52 +0000133 return A->getOption().matches(options::OPT_msoft_float) ||
134 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
135 A->getValue() == StringRef("soft"));
136}
137
Tim Northover157d9112014-01-16 08:48:16 +0000138StringRef MachO::getMachOArchName(const ArgList &Args) const {
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000139 switch (getTriple().getArch()) {
140 default:
Rafael Espindolaed1233e2014-08-28 21:23:05 +0000141 return getDefaultUniversalArchName();
NAKAMURA Takumi8b73b3e2011-06-03 03:49:51 +0000142
Tim Northover40956e62014-07-23 12:32:58 +0000143 case llvm::Triple::aarch64:
144 return "arm64";
145
Douglas Gregord9bb1522011-03-06 19:11:49 +0000146 case llvm::Triple::thumb:
Hans Wennborgdcfba332015-10-06 23:40:43 +0000147 case llvm::Triple::arm:
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000148 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
Renato Golin33e1f822015-05-28 15:49:28 +0000149 if (const char *Arch = ArmMachOArchName(A->getValue()))
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000150 return Arch;
151
152 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Renato Golin33e1f822015-05-28 15:49:28 +0000153 if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000154 return Arch;
155
156 return "arm";
157 }
Daniel Dunbardcc3b652010-01-22 02:04:58 +0000158}
159
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +0000160Darwin::~Darwin() {}
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000161
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +0000162MachO::~MachO() {}
Tim Northover157d9112014-01-16 08:48:16 +0000163
164std::string MachO::ComputeEffectiveClangTriple(const ArgList &Args,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000165 types::ID InputType) const {
Tim Northover157d9112014-01-16 08:48:16 +0000166 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
167
168 return Triple.getTriple();
169}
170
Chad Rosierd3a0f952011-09-20 20:44:06 +0000171std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
172 types::ID InputType) const {
173 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +0000174
175 // If the target isn't initialized (e.g., an unknown Darwin platform, return
176 // the default triple).
177 if (!isTargetInitialized())
178 return Triple.getTriple();
NAKAMURA Takumi8b73b3e2011-06-03 03:49:51 +0000179
Tim Northover157d9112014-01-16 08:48:16 +0000180 SmallString<16> Str;
181 Str += isTargetIOSBased() ? "ios" : "macosx";
182 Str += getTargetVersion().getAsString();
183 Triple.setOSName(Str);
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +0000184
185 return Triple.getTriple();
186}
187
David Blaikie68e081d2011-12-20 02:48:34 +0000188void Generic_ELF::anchor() {}
189
Tim Northover157d9112014-01-16 08:48:16 +0000190Tool *MachO::getTool(Action::ActionClass AC) const {
Rafael Espindola260e28d2013-03-18 20:48:54 +0000191 switch (AC) {
Rafael Espindolac8e3a012013-03-18 18:50:01 +0000192 case Action::LipoJobClass:
Rafael Espindola7cf32212013-03-20 03:05:54 +0000193 if (!Lipo)
194 Lipo.reset(new tools::darwin::Lipo(*this));
195 return Lipo.get();
Rafael Espindolac8e3a012013-03-18 18:50:01 +0000196 case Action::DsymutilJobClass:
Rafael Espindola7cf32212013-03-20 03:05:54 +0000197 if (!Dsymutil)
198 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
199 return Dsymutil.get();
Ben Langmuir9b9a8d32014-02-06 18:53:25 +0000200 case Action::VerifyDebugInfoJobClass:
Rafael Espindola7cf32212013-03-20 03:05:54 +0000201 if (!VerifyDebug)
202 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
203 return VerifyDebug.get();
Rafael Espindolad15a8912013-03-19 00:36:57 +0000204 default:
Rafael Espindola7cf32212013-03-20 03:05:54 +0000205 return ToolChain::getTool(AC);
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000206 }
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000207}
208
Douglas Katzman95354292015-06-23 20:42:09 +0000209Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
Rafael Espindola7cf32212013-03-20 03:05:54 +0000210
Tim Northover157d9112014-01-16 08:48:16 +0000211Tool *MachO::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +0000212 return new tools::darwin::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +0000213}
Daniel Dunbar26d482a2009-09-18 08:15:03 +0000214
Douglas Katzman95354292015-06-23 20:42:09 +0000215DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola84b588b2013-03-18 18:10:27 +0000216 const ArgList &Args)
Douglas Katzman95354292015-06-23 20:42:09 +0000217 : Darwin(D, Triple, Args) {}
Daniel Dunbar6276f992009-09-18 08:15:13 +0000218
Tim Northover336f1892014-03-29 13:16:12 +0000219void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
220 // For iOS, 64-bit, promote certain warnings to errors.
221 if (!isTargetMacOS() && getTriple().isArch64Bit()) {
222 // Always enable -Wdeprecated-objc-isa-usage and promote it
223 // to an error.
224 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
225 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
226
227 // Also error about implicit function declarations, as that
228 // can impact calling conventions.
229 CC1Args.push_back("-Werror=implicit-function-declaration");
230 }
231}
232
Tim Northover157d9112014-01-16 08:48:16 +0000233/// \brief Determine whether Objective-C automated reference counting is
234/// enabled.
235static bool isObjCAutoRefCount(const ArgList &Args) {
236 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
237}
238
John McCall31168b02011-06-15 23:02:42 +0000239void DarwinClang::AddLinkARCArgs(const ArgList &Args,
240 ArgStringList &CmdArgs) const {
Tim Northover157d9112014-01-16 08:48:16 +0000241 // Avoid linking compatibility stubs on i386 mac.
242 if (isTargetMacOS() && getArch() == llvm::Triple::x86)
243 return;
244
245 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
246
247 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
248 runtime.hasSubscripting())
249 return;
Eric Christopher551ef452011-08-23 17:56:55 +0000250
251 CmdArgs.push_back("-force_load");
Rafael Espindola358256c2013-06-26 02:13:00 +0000252 SmallString<128> P(getDriver().ClangExecutable);
253 llvm::sys::path::remove_filename(P); // 'clang'
254 llvm::sys::path::remove_filename(P); // 'bin'
Benjamin Kramer17381a02013-06-28 16:25:46 +0000255 llvm::sys::path::append(P, "lib", "arc", "libarclite_");
John McCall31168b02011-06-15 23:02:42 +0000256 // Mash in the platform.
Argyrios Kyrtzidis058b4512011-10-18 17:40:15 +0000257 if (isTargetIOSSimulator())
Rafael Espindola358256c2013-06-26 02:13:00 +0000258 P += "iphonesimulator";
Argyrios Kyrtzidis058b4512011-10-18 17:40:15 +0000259 else if (isTargetIPhoneOS())
Rafael Espindola358256c2013-06-26 02:13:00 +0000260 P += "iphoneos";
John McCall31168b02011-06-15 23:02:42 +0000261 else
Rafael Espindola358256c2013-06-26 02:13:00 +0000262 P += "macosx";
263 P += ".a";
John McCall31168b02011-06-15 23:02:42 +0000264
Rafael Espindola358256c2013-06-26 02:13:00 +0000265 CmdArgs.push_back(Args.MakeArgString(P));
John McCall31168b02011-06-15 23:02:42 +0000266}
267
Tim Northover157d9112014-01-16 08:48:16 +0000268void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
Kuba Brecka2735a0252014-10-31 00:08:57 +0000269 StringRef DarwinLibName, bool AlwaysLink,
Kuba Brecka9ff912d2014-11-04 17:35:17 +0000270 bool IsEmbedded, bool AddRPath) const {
271 SmallString<128> Dir(getDriver().ResourceDir);
272 llvm::sys::path::append(Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin");
273
274 SmallString<128> P(Dir);
275 llvm::sys::path::append(P, DarwinLibName);
Eric Christopher551ef452011-08-23 17:56:55 +0000276
Eric Christopherc235d0c62011-06-22 17:41:40 +0000277 // For now, allow missing resource libraries to support developers who may
Alexey Samsonov8368b372012-11-21 14:17:42 +0000278 // not have compiler-rt checked out or integrated into their build (unless
279 // we explicitly force linking with this library).
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000280 if (AlwaysLink || getVFS().exists(P))
Yaron Keren92e1b622015-03-18 10:17:07 +0000281 CmdArgs.push_back(Args.MakeArgString(P));
Kuba Brecka9ff912d2014-11-04 17:35:17 +0000282
283 // Adding the rpaths might negatively interact when other rpaths are involved,
284 // so we should make sure we add the rpaths last, after all user-specified
285 // rpaths. This is currently true from this place, but we need to be
286 // careful if this function is ever called before user's rpaths are emitted.
287 if (AddRPath) {
288 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
289
290 // Add @executable_path to rpath to support having the dylib copied with
291 // the executable.
292 CmdArgs.push_back("-rpath");
293 CmdArgs.push_back("@executable_path");
294
295 // Add the path to the resource dir to rpath to support using the dylib
296 // from the default location without copying.
297 CmdArgs.push_back("-rpath");
Yaron Keren92e1b622015-03-18 10:17:07 +0000298 CmdArgs.push_back(Args.MakeArgString(Dir));
Kuba Brecka9ff912d2014-11-04 17:35:17 +0000299 }
Eric Christopherc235d0c62011-06-22 17:41:40 +0000300}
301
Justin Bogner2fd95f62015-05-12 06:30:48 +0000302void Darwin::addProfileRTLibs(const ArgList &Args,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000303 ArgStringList &CmdArgs) const {
Xinliang David Li69306c02015-10-22 06:15:31 +0000304 if (!needsProfileRT(Args)) return;
Justin Bognerc7701242015-05-12 05:44:36 +0000305
306 // Select the appropriate runtime library for the target.
307 if (isTargetIOSBased())
308 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a",
309 /*AlwaysLink*/ true);
310 else
311 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a",
312 /*AlwaysLink*/ true);
Xinliang David Li69306c02015-10-22 06:15:31 +0000313 return;
Justin Bognerc7701242015-05-12 05:44:36 +0000314}
315
Alexey Samsonov498f3c32015-03-23 23:14:05 +0000316void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
317 ArgStringList &CmdArgs,
318 StringRef Sanitizer) const {
319 if (!Args.hasArg(options::OPT_dynamiclib) &&
320 !Args.hasArg(options::OPT_bundle)) {
321 // Sanitizer runtime libraries requires C++.
322 AddCXXStdlibLibArgs(Args, CmdArgs);
323 }
324 assert(isTargetMacOS() || isTargetIOSSimulator());
325 StringRef OS = isTargetMacOS() ? "osx" : "iossim";
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000326 AddLinkRuntimeLib(
327 Args, CmdArgs,
328 (Twine("libclang_rt.") + Sanitizer + "_" + OS + "_dynamic.dylib").str(),
329 /*AlwaysLink*/ true, /*IsEmbedded*/ false,
330 /*AddRPath*/ true);
Hans Wennborg10821e52015-04-09 18:47:01 +0000331
332 if (GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) {
333 // Add explicit dependcy on -lc++abi, as -lc++ doesn't re-export
334 // all RTTI-related symbols that UBSan uses.
335 CmdArgs.push_back("-lc++abi");
336 }
Alexey Samsonov498f3c32015-03-23 23:14:05 +0000337}
338
Daniel Dunbar6276f992009-09-18 08:15:13 +0000339void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
340 ArgStringList &CmdArgs) const {
Daniel Dunbarf4916cd2011-12-07 23:03:15 +0000341 // Darwin only supports the compiler-rt based runtime libraries.
342 switch (GetRuntimeLibType(Args)) {
343 case ToolChain::RLT_CompilerRT:
344 break;
345 default:
346 getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000347 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
Daniel Dunbarf4916cd2011-12-07 23:03:15 +0000348 return;
349 }
350
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000351 // Darwin doesn't support real static executables, don't link any runtime
352 // libraries with -static.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000353 if (Args.hasArg(options::OPT_static) ||
354 Args.hasArg(options::OPT_fapple_kext) ||
355 Args.hasArg(options::OPT_mkernel))
Daniel Dunbar6276f992009-09-18 08:15:13 +0000356 return;
Daniel Dunbar6276f992009-09-18 08:15:13 +0000357
358 // Reject -static-libgcc for now, we can deal with this when and if someone
359 // cares. This is useful in situations where someone wants to statically link
360 // something like libstdc++, and needs its runtime support routines.
361 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000362 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
Daniel Dunbar6276f992009-09-18 08:15:13 +0000363 return;
364 }
365
Peter Collingbourne32701642013-11-01 18:16:25 +0000366 const SanitizerArgs &Sanitize = getSanitizerArgs();
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +0000367 if (Sanitize.needsAsanRt())
368 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
369 if (Sanitize.needsUbsanRt())
370 AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan");
Daniel Dunbar1d6469f2011-12-01 23:40:18 +0000371
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000372 // Otherwise link libSystem, then the dynamic runtime library, and finally any
373 // target specific static runtime library.
Daniel Dunbar6276f992009-09-18 08:15:13 +0000374 CmdArgs.push_back("-lSystem");
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000375
376 // Select the dynamic runtime library and the target specific static library.
Tim Northover9c7e0352013-12-12 11:55:52 +0000377 if (isTargetIOSBased()) {
Daniel Dunbar2f31fb92011-04-30 04:25:16 +0000378 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
379 // it never went into the SDK.
Bob Wilson102be442011-10-07 17:54:41 +0000380 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
Tim Northovera2ee4332014-03-29 15:09:45 +0000381 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
Tim Northover40956e62014-07-23 12:32:58 +0000382 getTriple().getArch() != llvm::Triple::aarch64)
Bob Wilson102be442011-10-07 17:54:41 +0000383 CmdArgs.push_back("-lgcc_s.1");
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000384
Daniel Dunbard1076382011-04-18 23:48:36 +0000385 // We currently always need a static runtime library for iOS.
Eric Christopherc235d0c62011-06-22 17:41:40 +0000386 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000387 } else {
Tim Northover9c7e0352013-12-12 11:55:52 +0000388 assert(isTargetMacOS() && "unexpected non MacOS platform");
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000389 // The dynamic runtime library was merged with libSystem for 10.6 and
390 // beyond; only 10.4 and 10.5 need an additional runtime library.
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +0000391 if (isMacosxVersionLT(10, 5))
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000392 CmdArgs.push_back("-lgcc_s.10.4");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +0000393 else if (isMacosxVersionLT(10, 6))
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000394 CmdArgs.push_back("-lgcc_s.10.5");
395
Daniel Dunbarda4f6b52010-09-22 00:03:52 +0000396 // For OS X, we thought we would only need a static runtime library when
Chris Lattner57540c52011-04-15 05:22:18 +0000397 // targeting 10.4, to provide versions of the static functions which were
Daniel Dunbarda4f6b52010-09-22 00:03:52 +0000398 // omitted from 10.4.dylib.
399 //
400 // Unfortunately, that turned out to not be true, because Darwin system
401 // headers can still use eprintf on i386, and it is not exported from
402 // libSystem. Therefore, we still must provide a runtime library just for
403 // the tiny tiny handful of projects that *might* use that symbol.
404 if (isMacosxVersionLT(10, 5)) {
Eric Christopherc235d0c62011-06-22 17:41:40 +0000405 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
Daniel Dunbarda4f6b52010-09-22 00:03:52 +0000406 } else {
407 if (getTriple().getArch() == llvm::Triple::x86)
Eric Christopherc235d0c62011-06-22 17:41:40 +0000408 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
409 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
Daniel Dunbarda4f6b52010-09-22 00:03:52 +0000410 }
Daniel Dunbar7cde09a2010-01-22 03:38:14 +0000411 }
Daniel Dunbar6276f992009-09-18 08:15:13 +0000412}
413
Daniel Dunbar354e96d2010-07-19 17:11:36 +0000414void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +0000415 const OptTable &Opts = getDriver().getOpts();
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000416
Daniel Dunbar455a0492012-08-17 18:43:50 +0000417 // Support allowing the SDKROOT environment variable used by xcrun and other
418 // Xcode tools to define the default sysroot, by making it the default for
419 // isysroot.
Chad Rosier6c2b11c2012-12-19 23:41:50 +0000420 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
421 // Warn if the path does not exist.
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000422 if (!getVFS().exists(A->getValue()))
Chad Rosier6c2b11c2012-12-19 23:41:50 +0000423 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
424 } else {
Daniel Dunbar455a0492012-08-17 18:43:50 +0000425 if (char *env = ::getenv("SDKROOT")) {
Daniel Dunbarb2543042013-01-15 20:33:56 +0000426 // We only use this value as the default if it is an absolute path,
427 // exists, and it is not the root path.
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000428 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
Daniel Dunbarb2543042013-01-15 20:33:56 +0000429 StringRef(env) != "/") {
Daniel Dunbar455a0492012-08-17 18:43:50 +0000430 Args.append(Args.MakeSeparateArg(
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000431 nullptr, Opts.getOption(options::OPT_isysroot), env));
Daniel Dunbar455a0492012-08-17 18:43:50 +0000432 }
433 }
434 }
435
Daniel Dunbar3b8e50d2010-01-27 00:56:25 +0000436 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
Daniel Dunbar9aaeb642011-04-30 04:15:58 +0000437 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
Eli Friedman027e9c32012-01-11 02:41:15 +0000438
Bob Wilson7f294b52014-10-10 23:10:10 +0000439 if (OSXVersion && iOSVersion) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000440 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000441 << OSXVersion->getAsString(Args) << iOSVersion->getAsString(Args);
Bob Wilson7f294b52014-10-10 23:10:10 +0000442 iOSVersion = nullptr;
443 } else if (!OSXVersion && !iOSVersion) {
Chad Rosier64707fe2011-08-31 20:56:25 +0000444 // If no deployment target was specified on the command line, check for
Daniel Dunbard54669d2010-01-26 01:45:19 +0000445 // environment defines.
Alexey Samsonov905c8022015-06-18 21:46:05 +0000446 std::string OSXTarget;
447 std::string iOSTarget;
Chad Rosier64707fe2011-08-31 20:56:25 +0000448 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
449 OSXTarget = env;
450 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
451 iOSTarget = env;
Daniel Dunbarb5023e92009-04-10 21:00:07 +0000452
Steven Wu7a1372c2015-06-25 01:59:35 +0000453 // If there is no command-line argument to specify the Target version and
454 // no environment variable defined, see if we can set the default based
455 // on -isysroot.
456 if (iOSTarget.empty() && OSXTarget.empty() &&
457 Args.hasArg(options::OPT_isysroot)) {
Chad Rosier64707fe2011-08-31 20:56:25 +0000458 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000459 StringRef isysroot = A->getValue();
Steven Wu7a1372c2015-06-25 01:59:35 +0000460 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
461 size_t BeginSDK = isysroot.rfind("SDKs/");
462 size_t EndSDK = isysroot.rfind(".sdk");
463 if (BeginSDK != StringRef::npos && EndSDK != StringRef::npos) {
464 StringRef SDK = isysroot.slice(BeginSDK + 5, EndSDK);
465 // Slice the version number out.
466 // Version number is between the first and the last number.
467 size_t StartVer = SDK.find_first_of("0123456789");
468 size_t EndVer = SDK.find_last_of("0123456789");
469 if (StartVer != StringRef::npos && EndVer > StartVer) {
470 StringRef Version = SDK.slice(StartVer, EndVer + 1);
471 if (SDK.startswith("iPhoneOS") ||
472 SDK.startswith("iPhoneSimulator"))
473 iOSTarget = Version;
474 else if (SDK.startswith("MacOSX"))
475 OSXTarget = Version;
476 }
477 }
Chad Rosier64707fe2011-08-31 20:56:25 +0000478 }
479 }
Daniel Dunbard54669d2010-01-26 01:45:19 +0000480
Alexey Samsonovfd0bb3a2015-06-18 00:36:38 +0000481 // If no OSX or iOS target has been specified, try to guess platform
Alexey Samsonov905c8022015-06-18 21:46:05 +0000482 // from arch name and compute the version from the triple.
Alexey Samsonovfd0bb3a2015-06-18 00:36:38 +0000483 if (OSXTarget.empty() && iOSTarget.empty()) {
484 StringRef MachOArchName = getMachOArchName(Args);
Alexey Samsonov905c8022015-06-18 21:46:05 +0000485 unsigned Major, Minor, Micro;
Alexey Samsonovfd0bb3a2015-06-18 00:36:38 +0000486 if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
Alexey Samsonov905c8022015-06-18 21:46:05 +0000487 MachOArchName == "arm64") {
488 getTriple().getiOSVersion(Major, Minor, Micro);
489 llvm::raw_string_ostream(iOSTarget) << Major << '.' << Minor << '.'
490 << Micro;
491 } else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
492 MachOArchName != "armv7em") {
493 if (!getTriple().getMacOSXVersion(Major, Minor, Micro)) {
494 getDriver().Diag(diag::err_drv_invalid_darwin_version)
495 << getTriple().getOSName();
496 }
497 llvm::raw_string_ostream(OSXTarget) << Major << '.' << Minor << '.'
498 << Micro;
499 }
Alexey Samsonovfd0bb3a2015-06-18 00:36:38 +0000500 }
Chad Rosierfe6fd362011-09-28 00:46:32 +0000501
Daniel Dunbar9aaeb642011-04-30 04:15:58 +0000502 // Allow conflicts among OSX and iOS for historical reasons, but choose the
503 // default platform.
Chad Rosier64707fe2011-08-31 20:56:25 +0000504 if (!OSXTarget.empty() && !iOSTarget.empty()) {
Daniel Dunbarffa70e82010-02-02 17:31:12 +0000505 if (getTriple().getArch() == llvm::Triple::arm ||
Tim Northover573cbee2014-05-24 12:52:07 +0000506 getTriple().getArch() == llvm::Triple::aarch64 ||
Daniel Dunbarffa70e82010-02-02 17:31:12 +0000507 getTriple().getArch() == llvm::Triple::thumb)
Chad Rosier64707fe2011-08-31 20:56:25 +0000508 OSXTarget = "";
Daniel Dunbarffa70e82010-02-02 17:31:12 +0000509 else
Chad Rosier64707fe2011-08-31 20:56:25 +0000510 iOSTarget = "";
Daniel Dunbarffa70e82010-02-02 17:31:12 +0000511 }
Daniel Dunbar65969842010-01-29 17:02:25 +0000512
Chad Rosier64707fe2011-08-31 20:56:25 +0000513 if (!OSXTarget.empty()) {
Michael J. Spencerfc790902012-10-19 22:36:40 +0000514 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
Craig Topper92fc2df2014-05-17 16:56:41 +0000515 OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget);
Daniel Dunbar354e96d2010-07-19 17:11:36 +0000516 Args.append(OSXVersion);
Chad Rosier64707fe2011-08-31 20:56:25 +0000517 } else if (!iOSTarget.empty()) {
Michael J. Spencerfc790902012-10-19 22:36:40 +0000518 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
Craig Topper92fc2df2014-05-17 16:56:41 +0000519 iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget);
Daniel Dunbar9aaeb642011-04-30 04:15:58 +0000520 Args.append(iOSVersion);
Daniel Dunbar84e727f2009-09-04 18:35:21 +0000521 }
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000522 }
Mike Stump11289f42009-09-09 15:08:12 +0000523
Tim Northover9c7e0352013-12-12 11:55:52 +0000524 DarwinPlatformKind Platform;
525 if (OSXVersion)
526 Platform = MacOS;
527 else if (iOSVersion)
528 Platform = IPhoneOS;
Tim Northover9c7e0352013-12-12 11:55:52 +0000529 else
Tim Northover157d9112014-01-16 08:48:16 +0000530 llvm_unreachable("Unable to infer Darwin variant");
Tim Northover9c7e0352013-12-12 11:55:52 +0000531
Daniel Dunbar3b8e50d2010-01-27 00:56:25 +0000532 // Set the tool chain target information.
533 unsigned Major, Minor, Micro;
534 bool HadExtra;
Tim Northover9c7e0352013-12-12 11:55:52 +0000535 if (Platform == MacOS) {
Bob Wilson7f294b52014-10-10 23:10:10 +0000536 assert(!iOSVersion && "Unknown target platform!");
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000537 if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
538 HadExtra) ||
539 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000540 getDriver().Diag(diag::err_drv_invalid_version_number)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000541 << OSXVersion->getAsString(Args);
Bob Wilson7f294b52014-10-10 23:10:10 +0000542 } else if (Platform == IPhoneOS) {
543 assert(iOSVersion && "Unknown target platform!");
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000544 if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
545 HadExtra) ||
546 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
Eli Friedman027e9c32012-01-11 02:41:15 +0000547 getDriver().Diag(diag::err_drv_invalid_version_number)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000548 << iOSVersion->getAsString(Args);
Tim Northover157d9112014-01-16 08:48:16 +0000549 } else
550 llvm_unreachable("unknown kind of Darwin platform");
Daniel Dunbar9aaeb642011-04-30 04:15:58 +0000551
Bob Wilson7f294b52014-10-10 23:10:10 +0000552 // Recognize iOS targets with an x86 architecture as the iOS simulator.
Daniel Dunbarb1189432011-04-30 04:18:16 +0000553 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
554 getTriple().getArch() == llvm::Triple::x86_64))
Tim Northover9c7e0352013-12-12 11:55:52 +0000555 Platform = IPhoneOSSimulator;
Daniel Dunbarb1189432011-04-30 04:18:16 +0000556
Tim Northover9c7e0352013-12-12 11:55:52 +0000557 setTarget(Platform, Major, Minor, Micro);
Daniel Dunbarb2b8a912010-07-19 17:11:33 +0000558}
559
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000560void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
Daniel Dunbar8fa86b12010-09-17 01:16:06 +0000561 ArgStringList &CmdArgs) const {
562 CXXStdlibType Type = GetCXXStdlibType(Args);
563
564 switch (Type) {
565 case ToolChain::CST_Libcxx:
566 CmdArgs.push_back("-lc++");
567 break;
568
Hans Wennborgdcfba332015-10-06 23:40:43 +0000569 case ToolChain::CST_Libstdcxx:
Daniel Dunbar8fa86b12010-09-17 01:16:06 +0000570 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
571 // it was previously found in the gcc lib dir. However, for all the Darwin
572 // platforms we care about it was -lstdc++.6, so we search for that
573 // explicitly if we can't see an obvious -lstdc++ candidate.
574
575 // Check in the sysroot first.
576 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
Rafael Espindola358256c2013-06-26 02:13:00 +0000577 SmallString<128> P(A->getValue());
Benjamin Kramer17381a02013-06-28 16:25:46 +0000578 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
Daniel Dunbar8fa86b12010-09-17 01:16:06 +0000579
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000580 if (!getVFS().exists(P)) {
Rafael Espindola358256c2013-06-26 02:13:00 +0000581 llvm::sys::path::remove_filename(P);
582 llvm::sys::path::append(P, "libstdc++.6.dylib");
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000583 if (getVFS().exists(P)) {
Yaron Keren92e1b622015-03-18 10:17:07 +0000584 CmdArgs.push_back(Args.MakeArgString(P));
Daniel Dunbar8fa86b12010-09-17 01:16:06 +0000585 return;
586 }
587 }
588 }
589
590 // Otherwise, look in the root.
Bob Wilson1a9ad0f2011-11-11 07:47:04 +0000591 // FIXME: This should be removed someday when we don't have to care about
592 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000593 if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
594 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
Daniel Dunbar8fa86b12010-09-17 01:16:06 +0000595 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
596 return;
597 }
598
599 // Otherwise, let the linker search.
600 CmdArgs.push_back("-lstdc++");
601 break;
602 }
Daniel Dunbar8fa86b12010-09-17 01:16:06 +0000603}
604
Shantonu Senafeb03b2010-09-17 18:39:08 +0000605void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
606 ArgStringList &CmdArgs) const {
607
608 // For Darwin platforms, use the compiler-rt-based support library
609 // instead of the gcc-provided one (which is also incidentally
610 // only present in the gcc lib dir, which makes it hard to find).
611
Rafael Espindola358256c2013-06-26 02:13:00 +0000612 SmallString<128> P(getDriver().ResourceDir);
Benjamin Kramer17381a02013-06-28 16:25:46 +0000613 llvm::sys::path::append(P, "lib", "darwin");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000614
615 // Use the newer cc_kext for iOS ARM after 6.0.
Chris Bieneman25bc0de2015-09-23 22:52:35 +0000616 if (isTargetIPhoneOS()) {
617 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000618 } else {
Chris Bieneman25bc0de2015-09-23 22:52:35 +0000619 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000620 }
NAKAMURA Takumi8b73b3e2011-06-03 03:49:51 +0000621
Shantonu Senafeb03b2010-09-17 18:39:08 +0000622 // For now, allow missing resource libraries to support developers who may
623 // not have compiler-rt checked out or integrated into their build.
Benjamin Kramerd45b2052015-10-07 15:48:01 +0000624 if (getVFS().exists(P))
Yaron Keren92e1b622015-03-18 10:17:07 +0000625 CmdArgs.push_back(Args.MakeArgString(P));
Shantonu Senafeb03b2010-09-17 18:39:08 +0000626}
627
Tim Northover157d9112014-01-16 08:48:16 +0000628DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
629 const char *BoundArch) const {
Daniel Dunbarb2b8a912010-07-19 17:11:33 +0000630 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
631 const OptTable &Opts = getDriver().getOpts();
632
633 // FIXME: We really want to get out of the tool chain level argument
634 // translation business, as it makes the driver functionality much
635 // more opaque. For now, we follow gcc closely solely for the
636 // purpose of easily achieving feature parity & testability. Once we
637 // have something that works, we should reevaluate each translation
638 // and try to push it down into tool specific logic.
Daniel Dunbar3b8e50d2010-01-27 00:56:25 +0000639
Simon Atanasyan6f657c42014-05-08 19:32:46 +0000640 for (Arg *A : Args) {
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000641 if (A->getOption().matches(options::OPT_Xarch__)) {
Daniel Dunbar471c4f82011-06-21 00:20:17 +0000642 // Skip this argument unless the architecture matches either the toolchain
643 // triple arch, or the arch being bound.
Rafael Espindola35ca7d92012-10-07 04:44:33 +0000644 llvm::Triple::ArchType XarchArch =
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000645 tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
646 if (!(XarchArch == getArch() ||
647 (BoundArch &&
648 XarchArch ==
649 tools::darwin::getArchTypeForMachOArchName(BoundArch))))
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000650 continue;
651
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000652 Arg *OriginalArg = A;
Richard Smithbd55daf2012-11-01 04:30:05 +0000653 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +0000654 unsigned Prev = Index;
Nico Webera04d5f82014-05-11 17:27:13 +0000655 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
Mike Stump11289f42009-09-09 15:08:12 +0000656
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000657 // If the argument parsing failed or more than one argument was
658 // consumed, the -Xarch_ argument's parameter tried to consume
659 // extra arguments. Emit an error and ignore.
660 //
661 // We also want to disallow any options which would alter the
662 // driver behavior; that isn't going to work in our model. We
663 // use isDriverOption() as an approximation, although things
664 // like -O4 are going to slip through.
Daniel Dunbar5a784c82011-04-21 17:41:34 +0000665 if (!XarchArg || Index > Prev + 1) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000666 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000667 << A->getAsString(Args);
Daniel Dunbar6914a982011-04-21 17:32:21 +0000668 continue;
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000669 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000670 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000671 << A->getAsString(Args);
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000672 continue;
673 }
674
Daniel Dunbar53b406f2009-03-29 22:29:05 +0000675 XarchArg->setBaseArg(A);
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +0000676
Nico Webera04d5f82014-05-11 17:27:13 +0000677 A = XarchArg.release();
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +0000678 DAL->AddSynthesizedArg(A);
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000679
680 // Linker input arguments require custom handling. The problem is that we
681 // have already constructed the phase actions, so we can not treat them as
682 // "input arguments".
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000683 if (A->getOption().hasFlag(options::LinkerInput)) {
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000684 // Convert the argument into individual Zlinker_input_args.
Douglas Katzman6bbffc42015-06-25 18:51:37 +0000685 for (const char *Value : A->getValues()) {
686 DAL->AddSeparateArg(
687 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000688 }
689 continue;
690 }
Mike Stump11289f42009-09-09 15:08:12 +0000691 }
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000692
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000693 // Sob. These is strictly gcc compatible for the time being. Apple
694 // gcc translates options twice, which means that self-expanding
695 // options add duplicates.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000696 switch ((options::ID)A->getOption().getID()) {
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000697 default:
698 DAL->append(A);
699 break;
700
701 case options::OPT_mkernel:
702 case options::OPT_fapple_kext:
703 DAL->append(A);
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000704 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000705 break;
Mike Stump11289f42009-09-09 15:08:12 +0000706
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000707 case options::OPT_dependency_file:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000708 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000709 break;
710
711 case options::OPT_gfull:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000712 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000713 DAL->AddFlagArg(
714 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000715 break;
716
717 case options::OPT_gused:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000718 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000719 DAL->AddFlagArg(
720 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000721 break;
722
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000723 case options::OPT_shared:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000724 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000725 break;
726
727 case options::OPT_fconstant_cfstrings:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000728 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000729 break;
730
731 case options::OPT_fno_constant_cfstrings:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000732 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000733 break;
734
735 case options::OPT_Wnonportable_cfstrings:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000736 DAL->AddFlagArg(A,
737 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000738 break;
739
740 case options::OPT_Wno_nonportable_cfstrings:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000741 DAL->AddFlagArg(
742 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000743 break;
744
745 case options::OPT_fpascal_strings:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000746 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000747 break;
748
749 case options::OPT_fno_pascal_strings:
Daniel Dunbar2d6e9ee2010-06-14 20:20:41 +0000750 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000751 break;
752 }
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000753 }
754
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000755 if (getTriple().getArch() == llvm::Triple::x86 ||
756 getTriple().getArch() == llvm::Triple::x86_64)
Daniel Dunbarfffd1812009-11-19 04:00:53 +0000757 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
Craig Topper92fc2df2014-05-17 16:56:41 +0000758 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
759 "core2");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000760
761 // Add the arch options based on the particular spelling of -arch, to match
Chad Rosier7c5d9082012-04-27 14:58:16 +0000762 // how the driver driver works.
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000763 if (BoundArch) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000764 StringRef Name = BoundArch;
Michael J. Spencerfc790902012-10-19 22:36:40 +0000765 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
766 const Option MArch = Opts.getOption(options::OPT_march_EQ);
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000767
768 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
769 // which defines the list of which architectures we accept.
770 if (Name == "ppc")
771 ;
772 else if (Name == "ppc601")
Craig Topper92fc2df2014-05-17 16:56:41 +0000773 DAL->AddJoinedArg(nullptr, MCpu, "601");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000774 else if (Name == "ppc603")
Craig Topper92fc2df2014-05-17 16:56:41 +0000775 DAL->AddJoinedArg(nullptr, MCpu, "603");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000776 else if (Name == "ppc604")
Craig Topper92fc2df2014-05-17 16:56:41 +0000777 DAL->AddJoinedArg(nullptr, MCpu, "604");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000778 else if (Name == "ppc604e")
Craig Topper92fc2df2014-05-17 16:56:41 +0000779 DAL->AddJoinedArg(nullptr, MCpu, "604e");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000780 else if (Name == "ppc750")
Craig Topper92fc2df2014-05-17 16:56:41 +0000781 DAL->AddJoinedArg(nullptr, MCpu, "750");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000782 else if (Name == "ppc7400")
Craig Topper92fc2df2014-05-17 16:56:41 +0000783 DAL->AddJoinedArg(nullptr, MCpu, "7400");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000784 else if (Name == "ppc7450")
Craig Topper92fc2df2014-05-17 16:56:41 +0000785 DAL->AddJoinedArg(nullptr, MCpu, "7450");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000786 else if (Name == "ppc970")
Craig Topper92fc2df2014-05-17 16:56:41 +0000787 DAL->AddJoinedArg(nullptr, MCpu, "970");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000788
Bill Schmidt778d3872013-07-26 01:36:11 +0000789 else if (Name == "ppc64" || Name == "ppc64le")
Craig Topper92fc2df2014-05-17 16:56:41 +0000790 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000791
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000792 else if (Name == "i386")
793 ;
794 else if (Name == "i486")
Craig Topper92fc2df2014-05-17 16:56:41 +0000795 DAL->AddJoinedArg(nullptr, MArch, "i486");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000796 else if (Name == "i586")
Craig Topper92fc2df2014-05-17 16:56:41 +0000797 DAL->AddJoinedArg(nullptr, MArch, "i586");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000798 else if (Name == "i686")
Craig Topper92fc2df2014-05-17 16:56:41 +0000799 DAL->AddJoinedArg(nullptr, MArch, "i686");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000800 else if (Name == "pentium")
Craig Topper92fc2df2014-05-17 16:56:41 +0000801 DAL->AddJoinedArg(nullptr, MArch, "pentium");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000802 else if (Name == "pentium2")
Craig Topper92fc2df2014-05-17 16:56:41 +0000803 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000804 else if (Name == "pentpro")
Craig Topper92fc2df2014-05-17 16:56:41 +0000805 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000806 else if (Name == "pentIIm3")
Craig Topper92fc2df2014-05-17 16:56:41 +0000807 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000808
809 else if (Name == "x86_64")
Craig Topper92fc2df2014-05-17 16:56:41 +0000810 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
Jim Grosbach82eee262013-11-16 00:53:35 +0000811 else if (Name == "x86_64h") {
Craig Topper92fc2df2014-05-17 16:56:41 +0000812 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
813 DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
Jim Grosbach82eee262013-11-16 00:53:35 +0000814 }
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000815
816 else if (Name == "arm")
Craig Topper92fc2df2014-05-17 16:56:41 +0000817 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000818 else if (Name == "armv4t")
Craig Topper92fc2df2014-05-17 16:56:41 +0000819 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000820 else if (Name == "armv5")
Craig Topper92fc2df2014-05-17 16:56:41 +0000821 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000822 else if (Name == "xscale")
Craig Topper92fc2df2014-05-17 16:56:41 +0000823 DAL->AddJoinedArg(nullptr, MArch, "xscale");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000824 else if (Name == "armv6")
Craig Topper92fc2df2014-05-17 16:56:41 +0000825 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
Bob Wilson743bf672013-03-04 22:37:49 +0000826 else if (Name == "armv6m")
Craig Topper92fc2df2014-05-17 16:56:41 +0000827 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000828 else if (Name == "armv7")
Craig Topper92fc2df2014-05-17 16:56:41 +0000829 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
Bob Wilson743bf672013-03-04 22:37:49 +0000830 else if (Name == "armv7em")
Craig Topper92fc2df2014-05-17 16:56:41 +0000831 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
Bob Wilsond7cf1042012-09-29 23:52:50 +0000832 else if (Name == "armv7k")
Craig Topper92fc2df2014-05-17 16:56:41 +0000833 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
Bob Wilson743bf672013-03-04 22:37:49 +0000834 else if (Name == "armv7m")
Craig Topper92fc2df2014-05-17 16:56:41 +0000835 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
Bob Wilsond7cf1042012-09-29 23:52:50 +0000836 else if (Name == "armv7s")
Craig Topper92fc2df2014-05-17 16:56:41 +0000837 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
Daniel Dunbar3c7b9ca2009-09-09 22:33:15 +0000838 }
Daniel Dunbar0af75a12009-03-25 06:58:31 +0000839
Tim Northover157d9112014-01-16 08:48:16 +0000840 return DAL;
841}
842
Douglas Katzmanf08fadf2015-06-04 14:40:44 +0000843void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
844 ArgStringList &CmdArgs) const {
Tim Northover157d9112014-01-16 08:48:16 +0000845 // Embedded targets are simple at the moment, not supporting sanitizers and
846 // with different libraries for each member of the product { static, PIC } x
847 // { hard-float, soft-float }
848 llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000849 CompilerRT +=
850 (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
851 ? "hard"
852 : "soft";
Tim Northover157d9112014-01-16 08:48:16 +0000853 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
854
855 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
856}
857
Tim Northover157d9112014-01-16 08:48:16 +0000858DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
859 const char *BoundArch) const {
860 // First get the generic Apple args, before moving onto Darwin-specific ones.
861 DerivedArgList *DAL = MachO::TranslateArgs(Args, BoundArch);
862 const OptTable &Opts = getDriver().getOpts();
863
Bob Wilsonf8cf1612014-02-21 00:20:07 +0000864 // If no architecture is bound, none of the translations here are relevant.
865 if (!BoundArch)
866 return DAL;
867
Daniel Dunbar354e96d2010-07-19 17:11:36 +0000868 // Add an explicit version min argument for the deployment target. We do this
869 // after argument translation because -Xarch_ arguments may add a version min
870 // argument.
Bob Wilsonf8cf1612014-02-21 00:20:07 +0000871 AddDeploymentTarget(*DAL);
Daniel Dunbar354e96d2010-07-19 17:11:36 +0000872
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000873 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
874 // FIXME: It would be far better to avoid inserting those -static arguments,
875 // but we can't check the deployment target in the translation code until
876 // it is set here.
Bob Wilson5f4346d2014-12-02 00:27:35 +0000877 if (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000878 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie;) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000879 Arg *A = *it;
880 ++it;
881 if (A->getOption().getID() != options::OPT_mkernel &&
882 A->getOption().getID() != options::OPT_fapple_kext)
883 continue;
884 assert(it != ie && "unexpected argument translation");
885 A = *it;
886 assert(A->getOption().getID() == options::OPT_static &&
887 "missing expected -static argument");
888 it = DAL->getArgs().erase(it);
889 }
890 }
891
Bob Wilson0f7445b2013-11-02 23:19:53 +0000892 // Default to use libc++ on OS X 10.9+ and iOS 7+.
893 if (((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
Tim Northover9c7e0352013-12-12 11:55:52 +0000894 (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0))) &&
Bob Wilson0f7445b2013-11-02 23:19:53 +0000895 !Args.getLastArg(options::OPT_stdlib_EQ))
Craig Topper92fc2df2014-05-17 16:56:41 +0000896 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
897 "libc++");
Bob Wilson0f7445b2013-11-02 23:19:53 +0000898
Bob Wilson102be442011-10-07 17:54:41 +0000899 // Validate the C++ standard library choice.
900 CXXStdlibType Type = GetCXXStdlibType(*DAL);
901 if (Type == ToolChain::CST_Libcxx) {
John McCall5fb5df92012-06-20 06:18:46 +0000902 // Check whether the target provides libc++.
903 StringRef where;
904
Alp Tokerf6a24ce2013-12-05 16:25:25 +0000905 // Complain about targeting iOS < 5.0 in any way.
Tim Northover9c7e0352013-12-12 11:55:52 +0000906 if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
Bob Wilson5ad5a952012-11-09 01:59:30 +0000907 where = "iOS 5.0";
John McCall5fb5df92012-06-20 06:18:46 +0000908
909 if (where != StringRef()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000910 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
Bob Wilson102be442011-10-07 17:54:41 +0000911 }
912 }
913
Daniel Dunbaraabb0b12009-03-25 06:12:34 +0000914 return DAL;
Mike Stump11289f42009-09-09 15:08:12 +0000915}
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000916
Tim Northover157d9112014-01-16 08:48:16 +0000917bool MachO::IsUnwindTablesDefault() const {
Rafael Espindolae8bd4e52012-10-07 03:23:40 +0000918 return getArch() == llvm::Triple::x86_64;
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000919}
920
Tim Northover157d9112014-01-16 08:48:16 +0000921bool MachO::UseDwarfDebugFlags() const {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +0000922 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
923 return S[0] != '\0';
924 return false;
925}
926
Daniel Dunbar3241d402010-02-10 18:49:11 +0000927bool Darwin::UseSjLjExceptions() const {
928 // Darwin uses SjLj exceptions on ARM.
929 return (getTriple().getArch() == llvm::Triple::arm ||
930 getTriple().getArch() == llvm::Triple::thumb);
931}
932
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000933bool MachO::isPICDefault() const { return true; }
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000934
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000935bool MachO::isPIEDefault() const { return false; }
Peter Collingbourne54d770c2013-04-09 04:35:11 +0000936
Tim Northover157d9112014-01-16 08:48:16 +0000937bool MachO::isPICDefaultForced() const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000938 return (getArch() == llvm::Triple::x86_64 ||
Tim Northover573cbee2014-05-24 12:52:07 +0000939 getArch() == llvm::Triple::aarch64);
Daniel Dunbar03e0a4f2009-03-20 00:57:52 +0000940}
941
Tim Northover157d9112014-01-16 08:48:16 +0000942bool MachO::SupportsProfiling() const {
Daniel Dunbar733b0f82011-03-01 18:49:30 +0000943 // Profiling instrumentation is only supported on x86.
Rafael Espindola35ca7d92012-10-07 04:44:33 +0000944 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
Daniel Dunbar733b0f82011-03-01 18:49:30 +0000945}
946
Douglas Katzmanf08fadf2015-06-04 14:40:44 +0000947void Darwin::addMinVersionArgs(const ArgList &Args,
948 ArgStringList &CmdArgs) const {
Tim Northover157d9112014-01-16 08:48:16 +0000949 VersionTuple TargetVersion = getTargetVersion();
950
Bob Wilson771b7cd2014-10-10 19:38:34 +0000951 if (isTargetIOSSimulator())
Tim Northover157d9112014-01-16 08:48:16 +0000952 CmdArgs.push_back("-ios_simulator_version_min");
Bob Wilson5cfc55e2014-02-01 21:06:21 +0000953 else if (isTargetIOSBased())
Tim Northover157d9112014-01-16 08:48:16 +0000954 CmdArgs.push_back("-iphoneos_version_min");
955 else {
956 assert(isTargetMacOS() && "unexpected target");
957 CmdArgs.push_back("-macosx_version_min");
958 }
959
960 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
961}
962
Douglas Katzmanf08fadf2015-06-04 14:40:44 +0000963void Darwin::addStartObjectFileArgs(const ArgList &Args,
964 ArgStringList &CmdArgs) const {
Tim Northover157d9112014-01-16 08:48:16 +0000965 // Derived from startfile spec.
966 if (Args.hasArg(options::OPT_dynamiclib)) {
967 // Derived from darwin_dylib1 spec.
968 if (isTargetIOSSimulator()) {
Bob Wilson74b6cd12014-01-21 00:17:10 +0000969 ; // iOS simulator does not need dylib1.o.
Tim Northover157d9112014-01-16 08:48:16 +0000970 } else if (isTargetIPhoneOS()) {
971 if (isIPhoneOSVersionLT(3, 1))
972 CmdArgs.push_back("-ldylib1.o");
973 } else {
974 if (isMacosxVersionLT(10, 5))
975 CmdArgs.push_back("-ldylib1.o");
976 else if (isMacosxVersionLT(10, 6))
977 CmdArgs.push_back("-ldylib1.10.5.o");
978 }
979 } else {
980 if (Args.hasArg(options::OPT_bundle)) {
981 if (!Args.hasArg(options::OPT_static)) {
982 // Derived from darwin_bundle1 spec.
983 if (isTargetIOSSimulator()) {
Bob Wilson74b6cd12014-01-21 00:17:10 +0000984 ; // iOS simulator does not need bundle1.o.
Tim Northover157d9112014-01-16 08:48:16 +0000985 } else if (isTargetIPhoneOS()) {
986 if (isIPhoneOSVersionLT(3, 1))
987 CmdArgs.push_back("-lbundle1.o");
988 } else {
989 if (isMacosxVersionLT(10, 6))
990 CmdArgs.push_back("-lbundle1.o");
991 }
992 }
993 } else {
994 if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
995 if (Args.hasArg(options::OPT_static) ||
996 Args.hasArg(options::OPT_object) ||
997 Args.hasArg(options::OPT_preload)) {
998 CmdArgs.push_back("-lgcrt0.o");
999 } else {
1000 CmdArgs.push_back("-lgcrt1.o");
1001
1002 // darwin_crt2 spec is empty.
1003 }
1004 // By default on OS X 10.8 and later, we don't link with a crt1.o
1005 // file and the linker knows to use _main as the entry point. But,
1006 // when compiling with -pg, we need to link with the gcrt1.o file,
1007 // so pass the -no_new_main option to tell the linker to use the
1008 // "start" symbol as the entry point.
1009 if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
1010 CmdArgs.push_back("-no_new_main");
1011 } else {
1012 if (Args.hasArg(options::OPT_static) ||
1013 Args.hasArg(options::OPT_object) ||
1014 Args.hasArg(options::OPT_preload)) {
1015 CmdArgs.push_back("-lcrt0.o");
1016 } else {
1017 // Derived from darwin_crt1 spec.
1018 if (isTargetIOSSimulator()) {
Bob Wilson74b6cd12014-01-21 00:17:10 +00001019 ; // iOS simulator does not need crt1.o.
Tim Northover157d9112014-01-16 08:48:16 +00001020 } else if (isTargetIPhoneOS()) {
Tim Northover40956e62014-07-23 12:32:58 +00001021 if (getArch() == llvm::Triple::aarch64)
Tim Northovera2ee4332014-03-29 15:09:45 +00001022 ; // iOS does not need any crt1 files for arm64
1023 else if (isIPhoneOSVersionLT(3, 1))
Tim Northover157d9112014-01-16 08:48:16 +00001024 CmdArgs.push_back("-lcrt1.o");
1025 else if (isIPhoneOSVersionLT(6, 0))
1026 CmdArgs.push_back("-lcrt1.3.1.o");
1027 } else {
1028 if (isMacosxVersionLT(10, 5))
1029 CmdArgs.push_back("-lcrt1.o");
1030 else if (isMacosxVersionLT(10, 6))
1031 CmdArgs.push_back("-lcrt1.10.5.o");
1032 else if (isMacosxVersionLT(10, 8))
1033 CmdArgs.push_back("-lcrt1.10.6.o");
1034
1035 // darwin_crt2 spec is empty.
1036 }
1037 }
1038 }
1039 }
1040 }
1041
1042 if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
1043 isMacosxVersionLT(10, 5)) {
1044 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
1045 CmdArgs.push_back(Str);
1046 }
1047}
1048
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001049bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
Daniel Dunbar16334e12010-04-10 16:20:23 +00001050
John McCall3deb1ad2012-08-21 02:47:43 +00001051void Darwin::CheckObjCARC() const {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001052 if (isTargetIOSBased() || (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
John McCall3deb1ad2012-08-21 02:47:43 +00001053 return;
John McCall93207072012-08-27 01:56:21 +00001054 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00001055}
1056
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00001057SanitizerMask Darwin::getSupportedSanitizers() const {
1058 SanitizerMask Res = ToolChain::getSupportedSanitizers();
Alexey Samsonov1d4cff22015-06-25 00:58:02 +00001059 if (isTargetMacOS() || isTargetIOSSimulator())
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00001060 Res |= SanitizerKind::Address;
Alexey Samsonov1d4cff22015-06-25 00:58:02 +00001061 if (isTargetMacOS()) {
1062 if (!isMacosxVersionLT(10, 9))
1063 Res |= SanitizerKind::Vptr;
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00001064 Res |= SanitizerKind::SafeStack;
Alexey Samsonov1d4cff22015-06-25 00:58:02 +00001065 }
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00001066 return Res;
1067}
1068
Daniel Dunbar59e5e882009-03-20 00:20:03 +00001069/// Generic_GCC - A tool chain using the 'gcc' command to perform
1070/// all subcommands; this relies on gcc translating the majority of
1071/// command line options.
1072
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001073/// \brief Parse a GCCVersion object out of a string of text.
1074///
1075/// This is the primary means of forming GCCVersion objects.
1076/*static*/
1077Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001078 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001079 std::pair<StringRef, StringRef> First = VersionText.split('.');
1080 std::pair<StringRef, StringRef> Second = First.second.split('.');
1081
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001082 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1083 if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001084 return BadVersion;
Chandler Carruth1f2b2f82013-08-26 08:59:53 +00001085 GoodVersion.MajorStr = First.first.str();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001086 if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001087 return BadVersion;
Chandler Carruth1f2b2f82013-08-26 08:59:53 +00001088 GoodVersion.MinorStr = Second.first.str();
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001089
1090 // First look for a number prefix and parse that if present. Otherwise just
1091 // stash the entire patch string in the suffix, and leave the number
1092 // unspecified. This covers versions strings such as:
1093 // 4.4
1094 // 4.4.0
1095 // 4.4.x
1096 // 4.4.2-rc4
1097 // 4.4.x-patched
1098 // And retains any patch number it finds.
1099 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1100 if (!PatchText.empty()) {
Will Dietza38608b2013-01-10 22:20:02 +00001101 if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001102 // Try to parse the number and any suffix.
1103 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1104 GoodVersion.Patch < 0)
1105 return BadVersion;
Chandler Carruth1f2b2f82013-08-26 08:59:53 +00001106 GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001107 }
1108 }
1109
1110 return GoodVersion;
1111}
1112
1113/// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
Benjamin Kramer604e8482013-08-09 17:17:48 +00001114bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1115 int RHSPatch,
1116 StringRef RHSPatchSuffix) const {
1117 if (Major != RHSMajor)
1118 return Major < RHSMajor;
1119 if (Minor != RHSMinor)
1120 return Minor < RHSMinor;
1121 if (Patch != RHSPatch) {
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001122 // Note that versions without a specified patch sort higher than those with
1123 // a patch.
Benjamin Kramer604e8482013-08-09 17:17:48 +00001124 if (RHSPatch == -1)
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001125 return true;
1126 if (Patch == -1)
1127 return false;
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001128
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001129 // Otherwise just sort on the patch itself.
Benjamin Kramer604e8482013-08-09 17:17:48 +00001130 return Patch < RHSPatch;
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001131 }
Benjamin Kramer604e8482013-08-09 17:17:48 +00001132 if (PatchSuffix != RHSPatchSuffix) {
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001133 // Sort empty suffixes higher.
Benjamin Kramer604e8482013-08-09 17:17:48 +00001134 if (RHSPatchSuffix.empty())
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001135 return true;
1136 if (PatchSuffix.empty())
Chandler Carruth19e8bea2012-12-29 13:00:47 +00001137 return false;
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001138
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001139 // Provide a lexicographic sort to make this a total ordering.
Benjamin Kramer604e8482013-08-09 17:17:48 +00001140 return PatchSuffix < RHSPatchSuffix;
Chandler Carruth5193dfc2012-12-29 12:01:08 +00001141 }
1142
1143 // The versions are equal.
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001144 return false;
1145}
1146
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001147static llvm::StringRef getGCCToolchainDir(const ArgList &Args) {
Rafael Espindola1af7c212012-02-19 01:38:32 +00001148 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1149 if (A)
Richard Smithbd55daf2012-11-01 04:30:05 +00001150 return A->getValue();
Rafael Espindola1af7c212012-02-19 01:38:32 +00001151 return GCC_INSTALL_PREFIX;
1152}
1153
Roman Divacky326d9982013-12-06 18:32:18 +00001154/// \brief Initialize a GCCInstallationDetector from the driver.
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001155///
1156/// This performs all of the autodetection and sets up the various paths.
Gabor Greif8a45d572012-04-17 11:16:26 +00001157/// Once constructed, a GCCInstallationDetector is essentially immutable.
Chandler Carruth866faab2012-01-25 07:21:38 +00001158///
1159/// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1160/// should instead pull the target out of the driver. This is currently
1161/// necessary because the driver doesn't store the final version of the target
1162/// triple.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001163void Generic_GCC::GCCInstallationDetector::init(
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001164 const llvm::Triple &TargetTriple, const ArgList &Args,
Douglas Katzman8c39e6a2015-09-18 15:23:16 +00001165 ArrayRef<std::string> ExtraTripleAliases) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001166 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1167 ? TargetTriple.get64BitArchVariant()
1168 : TargetTriple.get32BitArchVariant();
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001169 // The library directories which may contain GCC installations.
Chandler Carruthb427c562013-06-22 11:35:51 +00001170 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001171 // The compatible GCC triples for this particular architecture.
Hans Wennborg90aa63f2014-08-11 18:09:28 +00001172 SmallVector<StringRef, 16> CandidateTripleAliases;
1173 SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
Chandler Carruthb427c562013-06-22 11:35:51 +00001174 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1175 CandidateTripleAliases, CandidateBiarchLibDirs,
1176 CandidateBiarchTripleAliases);
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001177
1178 // Compute the set of prefixes for our search.
1179 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1180 D.PrefixDirs.end());
Rafael Espindolac29af942012-02-03 01:01:20 +00001181
Rafael Espindola1af7c212012-02-19 01:38:32 +00001182 StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1183 if (GCCToolchainDir != "") {
1184 if (GCCToolchainDir.back() == '/')
1185 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
Rafael Espindolac29af942012-02-03 01:01:20 +00001186
Rafael Espindola1af7c212012-02-19 01:38:32 +00001187 Prefixes.push_back(GCCToolchainDir);
Rafael Espindolac29af942012-02-03 01:01:20 +00001188 } else {
Rafael Espindola0f4b04e2013-08-28 23:17:47 +00001189 // If we have a SysRoot, try that first.
1190 if (!D.SysRoot.empty()) {
1191 Prefixes.push_back(D.SysRoot);
1192 Prefixes.push_back(D.SysRoot + "/usr");
1193 }
1194
1195 // Then look for gcc installed alongside clang.
Rafael Espindolac29af942012-02-03 01:01:20 +00001196 Prefixes.push_back(D.InstalledDir + "/..");
Rafael Espindola0f4b04e2013-08-28 23:17:47 +00001197
1198 // And finally in /usr.
1199 if (D.SysRoot.empty())
1200 Prefixes.push_back("/usr");
Rafael Espindolac29af942012-02-03 01:01:20 +00001201 }
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001202
1203 // Loop over the various components which exist and select the best GCC
1204 // installation available. GCC installs are ranked by version number.
1205 Version = GCCVersion::Parse("0.0.0");
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001206 for (const std::string &Prefix : Prefixes) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001207 if (!D.getVFS().exists(Prefix))
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001208 continue;
Benjamin Kramer72e64312015-09-24 14:48:49 +00001209 for (StringRef Suffix : CandidateLibDirs) {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001210 const std::string LibDir = Prefix + Suffix.str();
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001211 if (!D.getVFS().exists(LibDir))
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001212 continue;
Benjamin Kramer72e64312015-09-24 14:48:49 +00001213 for (StringRef Candidate : ExtraTripleAliases) // Try these first.
Douglas Katzmand6e597c2015-09-17 19:56:40 +00001214 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
Benjamin Kramer72e64312015-09-24 14:48:49 +00001215 for (StringRef Candidate : CandidateTripleAliases)
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001216 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
Chandler Carruth866faab2012-01-25 07:21:38 +00001217 }
Benjamin Kramer72e64312015-09-24 14:48:49 +00001218 for (StringRef Suffix : CandidateBiarchLibDirs) {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001219 const std::string LibDir = Prefix + Suffix.str();
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001220 if (!D.getVFS().exists(LibDir))
Chandler Carruth866faab2012-01-25 07:21:38 +00001221 continue;
Benjamin Kramer72e64312015-09-24 14:48:49 +00001222 for (StringRef Candidate : CandidateBiarchTripleAliases)
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001223 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
Chandler Carruthb427c562013-06-22 11:35:51 +00001224 /*NeedsBiarchSuffix=*/ true);
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001225 }
1226 }
1227}
1228
Chandler Carruth0ae39aa2013-07-30 17:57:09 +00001229void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
Simon Atanasyan6f657c42014-05-08 19:32:46 +00001230 for (const auto &InstallPath : CandidateGCCInstallPaths)
1231 OS << "Found candidate GCC installation: " << InstallPath << "\n";
Chandler Carruth0ae39aa2013-07-30 17:57:09 +00001232
Yunzhong Gaoe3f902c2014-02-19 19:06:58 +00001233 if (!GCCInstallPath.empty())
1234 OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1235
Simon Atanasyan6f657c42014-05-08 19:32:46 +00001236 for (const auto &Multilib : Multilibs)
1237 OS << "Candidate multilib: " << Multilib << "\n";
Yunzhong Gaoe3f902c2014-02-19 19:06:58 +00001238
1239 if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1240 OS << "Selected multilib: " << SelectedMultilib << "\n";
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001241}
1242
1243bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1244 if (BiarchSibling.hasValue()) {
1245 M = BiarchSibling.getValue();
1246 return true;
1247 }
1248 return false;
Chandler Carruth0ae39aa2013-07-30 17:57:09 +00001249}
1250
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001251/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
Chandler Carruthb427c562013-06-22 11:35:51 +00001252 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
Chandler Carruth866faab2012-01-25 07:21:38 +00001253 SmallVectorImpl<StringRef> &LibDirs,
1254 SmallVectorImpl<StringRef> &TripleAliases,
Chandler Carruthb427c562013-06-22 11:35:51 +00001255 SmallVectorImpl<StringRef> &BiarchLibDirs,
1256 SmallVectorImpl<StringRef> &BiarchTripleAliases) {
Chandler Carruth866faab2012-01-25 07:21:38 +00001257 // Declare a bunch of static data sets that we'll select between below. These
1258 // are specifically designed to always refer to string literals to avoid any
1259 // lifetime or initialization issues.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001260 static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
1261 static const char *const AArch64Triples[] = {
1262 "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android",
1263 "aarch64-redhat-linux"};
1264 static const char *const AArch64beLibDirs[] = {"/lib"};
1265 static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
1266 "aarch64_be-linux-gnu"};
Tim Northover9bb857a2013-01-31 12:13:10 +00001267
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001268 static const char *const ARMLibDirs[] = {"/lib"};
1269 static const char *const ARMTriples[] = {"arm-linux-gnueabi",
1270 "arm-linux-androideabi"};
1271 static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
1272 "armv7hl-redhat-linux-gnueabi"};
1273 static const char *const ARMebLibDirs[] = {"/lib"};
1274 static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
1275 "armeb-linux-androideabi"};
1276 static const char *const ARMebHFTriples[] = {
1277 "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001278
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001279 static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001280 static const char *const X86_64Triples[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001281 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
1282 "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
1283 "x86_64-redhat-linux", "x86_64-suse-linux",
1284 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
1285 "x86_64-slackware-linux", "x86_64-linux-android",
1286 "x86_64-unknown-linux"};
1287 static const char *const X32LibDirs[] = {"/libx32"};
1288 static const char *const X86LibDirs[] = {"/lib32", "/lib"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001289 static const char *const X86Triples[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001290 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu",
1291 "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux",
1292 "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux",
1293 "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android",
1294 "i586-linux-gnu"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001295
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001296 static const char *const MIPSLibDirs[] = {"/lib"};
Vasileios Kalintirisfdfc0102015-10-05 10:34:46 +00001297 static const char *const MIPSTriples[] = {
1298 "mips-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu"};
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001299 static const char *const MIPSELLibDirs[] = {"/lib"};
1300 static const char *const MIPSELTriples[] = {
1301 "mipsel-linux-gnu", "mipsel-linux-android", "mips-img-linux-gnu"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001302
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001303 static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
1304 static const char *const MIPS64Triples[] = {
1305 "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1306 "mips64-linux-gnuabi64"};
1307 static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
1308 static const char *const MIPS64ELTriples[] = {
1309 "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1310 "mips64el-linux-android", "mips64el-linux-gnuabi64"};
Simon Atanasyan9bb634d2012-04-26 19:57:02 +00001311
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001312 static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001313 static const char *const PPCTriples[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001314 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1315 "powerpc-suse-linux", "powerpc-montavista-linuxspe"};
1316 static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
1317 static const char *const PPC64Triples[] = {
1318 "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
1319 "powerpc64-suse-linux", "ppc64-redhat-linux"};
1320 static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
1321 static const char *const PPC64LETriples[] = {
1322 "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
1323 "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
Chandler Carruth866faab2012-01-25 07:21:38 +00001324
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001325 static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
1326 static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
1327 "sparcv8-linux-gnu"};
1328 static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
1329 static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
1330 "sparcv9-linux-gnu"};
Jakob Stoklund Olesenb3f938e2014-01-10 06:53:02 +00001331
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001332 static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
Ulrich Weigand47445072013-05-06 16:26:41 +00001333 static const char *const SystemZTriples[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001334 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1335 "s390x-suse-linux", "s390x-redhat-linux"};
Ulrich Weigand47445072013-05-06 16:26:41 +00001336
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001337 // Solaris.
1338 static const char *const SolarisSPARCLibDirs[] = {"/gcc"};
1339 static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11",
1340 "i386-pc-solaris2.11"};
1341
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001342 using std::begin;
1343 using std::end;
1344
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001345 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1346 LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));
1347 TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001348 return;
1349 }
1350
Chandler Carruth866faab2012-01-25 07:21:38 +00001351 switch (TargetTriple.getArch()) {
Tim Northover9bb857a2013-01-31 12:13:10 +00001352 case llvm::Triple::aarch64:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001353 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1354 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1355 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1356 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
Tim Northover9bb857a2013-01-31 12:13:10 +00001357 break;
Christian Pirkera74c7912014-03-14 12:15:45 +00001358 case llvm::Triple::aarch64_be:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001359 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1360 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1361 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1362 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
Christian Pirkera74c7912014-03-14 12:15:45 +00001363 break;
Chandler Carruth866faab2012-01-25 07:21:38 +00001364 case llvm::Triple::arm:
1365 case llvm::Triple::thumb:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001366 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
Jiangning Liu61b06cb2012-07-31 08:06:29 +00001367 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001368 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
Jiangning Liu61b06cb2012-07-31 08:06:29 +00001369 } else {
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001370 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
Jiangning Liu61b06cb2012-07-31 08:06:29 +00001371 }
Chandler Carruth866faab2012-01-25 07:21:38 +00001372 break;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001373 case llvm::Triple::armeb:
1374 case llvm::Triple::thumbeb:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001375 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001376 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001377 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001378 } else {
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001379 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001380 }
1381 break;
Chandler Carruth866faab2012-01-25 07:21:38 +00001382 case llvm::Triple::x86_64:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001383 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1384 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1385 // x32 is always available when x86_64 is available, so adding it as
1386 // secondary arch with x86_64 triples
Zinovy Nis1db95732014-07-10 15:27:19 +00001387 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001388 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1389 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
Zinovy Nis1db95732014-07-10 15:27:19 +00001390 } else {
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001391 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1392 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
Zinovy Nis1db95732014-07-10 15:27:19 +00001393 }
Chandler Carruth866faab2012-01-25 07:21:38 +00001394 break;
1395 case llvm::Triple::x86:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001396 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1397 TripleAliases.append(begin(X86Triples), end(X86Triples));
1398 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1399 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
Chandler Carruth866faab2012-01-25 07:21:38 +00001400 break;
1401 case llvm::Triple::mips:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001402 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1403 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1404 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1405 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
Chandler Carruth866faab2012-01-25 07:21:38 +00001406 break;
1407 case llvm::Triple::mipsel:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001408 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1409 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1410 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1411 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1412 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
Simon Atanasyan9bb634d2012-04-26 19:57:02 +00001413 break;
1414 case llvm::Triple::mips64:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001415 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1416 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1417 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1418 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
Simon Atanasyan9bb634d2012-04-26 19:57:02 +00001419 break;
1420 case llvm::Triple::mips64el:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001421 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1422 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1423 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1424 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1425 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
Chandler Carruth866faab2012-01-25 07:21:38 +00001426 break;
1427 case llvm::Triple::ppc:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001428 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1429 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
1430 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1431 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
Chandler Carruth866faab2012-01-25 07:21:38 +00001432 break;
1433 case llvm::Triple::ppc64:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001434 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1435 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1436 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1437 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
Chandler Carruth866faab2012-01-25 07:21:38 +00001438 break;
Bill Schmidt778d3872013-07-26 01:36:11 +00001439 case llvm::Triple::ppc64le:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001440 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
1441 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
Bill Schmidt778d3872013-07-26 01:36:11 +00001442 break;
Jakob Stoklund Olesenb3f938e2014-01-10 06:53:02 +00001443 case llvm::Triple::sparc:
Douglas Katzmanb76a3df2015-09-02 13:33:42 +00001444 case llvm::Triple::sparcel:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001445 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1446 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1447 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1448 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
Jakob Stoklund Olesenb3f938e2014-01-10 06:53:02 +00001449 break;
1450 case llvm::Triple::sparcv9:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001451 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1452 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1453 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1454 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
Jakob Stoklund Olesenb3f938e2014-01-10 06:53:02 +00001455 break;
Ulrich Weigand47445072013-05-06 16:26:41 +00001456 case llvm::Triple::systemz:
Benjamin Kramer6ec434e2014-10-18 10:43:51 +00001457 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
1458 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
Ulrich Weigand47445072013-05-06 16:26:41 +00001459 break;
Chandler Carruth866faab2012-01-25 07:21:38 +00001460 default:
1461 // By default, just rely on the standard lib directories and the original
1462 // triple.
1463 break;
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001464 }
Chandler Carruth866faab2012-01-25 07:21:38 +00001465
1466 // Always append the drivers target triple to the end, in case it doesn't
1467 // match any of our aliases.
1468 TripleAliases.push_back(TargetTriple.str());
1469
1470 // Also include the multiarch variant if it's different.
Chandler Carruthb427c562013-06-22 11:35:51 +00001471 if (TargetTriple.str() != BiarchTriple.str())
1472 BiarchTripleAliases.push_back(BiarchTriple.str());
Chandler Carruth4c90fba2011-11-06 23:39:34 +00001473}
1474
Artem Belevich98607b62015-09-23 21:49:39 +00001475// \brief -- try common CUDA installation paths looking for files we need for
1476// CUDA compilation.
1477
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001478void Generic_GCC::CudaInstallationDetector::init(
1479 const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args) {
NAKAMURA Takumi0c8decd2015-09-24 03:15:44 +00001480 SmallVector<std::string, 4> CudaPathCandidates;
Artem Belevich98607b62015-09-23 21:49:39 +00001481
1482 if (Args.hasArg(options::OPT_cuda_path_EQ))
1483 CudaPathCandidates.push_back(
1484 Args.getLastArgValue(options::OPT_cuda_path_EQ));
1485 else {
1486 CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda");
1487 CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.0");
1488 }
1489
Benjamin Kramere8b76412015-09-24 14:48:37 +00001490 for (const auto &CudaPath : CudaPathCandidates) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001491 if (CudaPath.empty() || !D.getVFS().exists(CudaPath))
Artem Belevich98607b62015-09-23 21:49:39 +00001492 continue;
1493
1494 CudaInstallPath = CudaPath;
1495 CudaIncludePath = CudaInstallPath + "/include";
1496 CudaLibDevicePath = CudaInstallPath + "/nvvm/libdevice";
1497 CudaLibPath =
1498 CudaInstallPath + (TargetTriple.isArch64Bit() ? "/lib64" : "/lib");
1499
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001500 if (!(D.getVFS().exists(CudaIncludePath) &&
1501 D.getVFS().exists(CudaLibPath) &&
1502 D.getVFS().exists(CudaLibDevicePath)))
Artem Belevich98607b62015-09-23 21:49:39 +00001503 continue;
1504
1505 IsValid = true;
1506 break;
1507 }
1508}
1509
1510void Generic_GCC::CudaInstallationDetector::print(raw_ostream &OS) const {
1511 if (isValid())
1512 OS << "Found CUDA installation: " << CudaInstallPath << "\n";
1513}
1514
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001515namespace {
1516// Filter to remove Multilibs that don't exist as a suffix to Path
Benjamin Kramerac75baa2015-03-22 15:56:12 +00001517class FilterNonExistent {
1518 StringRef Base;
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001519 vfs::FileSystem &VFS;
Benjamin Kramerac75baa2015-03-22 15:56:12 +00001520
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001521public:
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001522 FilterNonExistent(StringRef Base, vfs::FileSystem &VFS)
1523 : Base(Base), VFS(VFS) {}
Benjamin Kramerac75baa2015-03-22 15:56:12 +00001524 bool operator()(const Multilib &M) {
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001525 return !VFS.exists(Base + M.gccSuffix() + "/crtbegin.o");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001526 }
1527};
1528} // end anonymous namespace
1529
1530static void addMultilibFlag(bool Enabled, const char *const Flag,
1531 std::vector<std::string> &Flags) {
1532 if (Enabled)
1533 Flags.push_back(std::string("+") + Flag);
1534 else
1535 Flags.push_back(std::string("-") + Flag);
1536}
1537
Simon Atanasyan08450bd2013-04-20 08:15:03 +00001538static bool isMipsArch(llvm::Triple::ArchType Arch) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001539 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1540 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1541}
1542
1543static bool isMips32(llvm::Triple::ArchType Arch) {
1544 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1545}
1546
1547static bool isMips64(llvm::Triple::ArchType Arch) {
1548 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1549}
1550
1551static bool isMipsEL(llvm::Triple::ArchType Arch) {
1552 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1553}
1554
Simon Atanasyan08450bd2013-04-20 08:15:03 +00001555static bool isMips16(const ArgList &Args) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001556 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
Simon Atanasyan08450bd2013-04-20 08:15:03 +00001557 return A && A->getOption().matches(options::OPT_mips16);
1558}
1559
1560static bool isMicroMips(const ArgList &Args) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001561 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
Simon Atanasyan08450bd2013-04-20 08:15:03 +00001562 return A && A->getOption().matches(options::OPT_mmicromips);
1563}
1564
Benjamin Kramere003ca22015-10-28 13:54:16 +00001565namespace {
Simon Atanasyan60280b42014-05-12 07:37:51 +00001566struct DetectedMultilibs {
1567 /// The set of multilibs that the detected installation supports.
1568 MultilibSet Multilibs;
1569
1570 /// The primary multilib appropriate for the given flags.
1571 Multilib SelectedMultilib;
1572
1573 /// On Biarch systems, this corresponds to the default multilib when
1574 /// targeting the non-default multilib. Otherwise, it is empty.
1575 llvm::Optional<Multilib> BiarchSibling;
1576};
Benjamin Kramere003ca22015-10-28 13:54:16 +00001577} // end anonymous namespace
Simon Atanasyan60280b42014-05-12 07:37:51 +00001578
Simon Atanasyan1b0542e2014-07-30 09:15:10 +00001579static Multilib makeMultilib(StringRef commonSuffix) {
1580 return Multilib(commonSuffix, commonSuffix, commonSuffix);
1581}
1582
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001583static bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
1584 StringRef Path, const ArgList &Args,
1585 DetectedMultilibs &Result) {
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00001586 // Some MIPS toolchains put libraries and object files compiled
1587 // using different options in to the sub-directoris which names
1588 // reflects the flags used for compilation. For example sysroot
1589 // directory might looks like the following examples:
1590 //
1591 // /usr
1592 // /lib <= crt*.o files compiled with '-mips32'
1593 // /mips16
1594 // /usr
1595 // /lib <= crt*.o files compiled with '-mips16'
1596 // /el
1597 // /usr
1598 // /lib <= crt*.o files compiled with '-mips16 -EL'
1599 //
1600 // or
1601 //
1602 // /usr
1603 // /lib <= crt*.o files compiled with '-mips32r2'
1604 // /mips16
1605 // /usr
1606 // /lib <= crt*.o files compiled with '-mips32r2 -mips16'
1607 // /mips32
1608 // /usr
1609 // /lib <= crt*.o files compiled with '-mips32'
Simon Atanasyanee1accf2013-09-28 13:45:11 +00001610
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001611 FilterNonExistent NonExistent(Path, D.getVFS());
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001612
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001613 // Check for FSF toolchain multilibs
1614 MultilibSet FSFMipsMultilibs;
1615 {
Simon Atanasyan1b0542e2014-07-30 09:15:10 +00001616 auto MArchMips32 = makeMultilib("/mips32")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001617 .flag("+m32")
1618 .flag("-m64")
1619 .flag("-mmicromips")
1620 .flag("+march=mips32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001621
Simon Atanasyan1b0542e2014-07-30 09:15:10 +00001622 auto MArchMicroMips = makeMultilib("/micromips")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001623 .flag("+m32")
1624 .flag("-m64")
1625 .flag("+mmicromips");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001626
Simon Atanasyan1b0542e2014-07-30 09:15:10 +00001627 auto MArchMips64r2 = makeMultilib("/mips64r2")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001628 .flag("-m32")
1629 .flag("+m64")
1630 .flag("+march=mips64r2");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001631
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001632 auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
1633 "-march=mips64r2");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001634
Simon Atanasyan1b0542e2014-07-30 09:15:10 +00001635 auto MArchDefault = makeMultilib("")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001636 .flag("+m32")
1637 .flag("-m64")
1638 .flag("-mmicromips")
1639 .flag("+march=mips32r2");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001640
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001641 auto Mips16 = makeMultilib("/mips16").flag("+mips16");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001642
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001643 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00001644
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001645 auto MAbi64 =
1646 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001647
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001648 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001649
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001650 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001651
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001652 auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001653
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001654 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001655
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001656 FSFMipsMultilibs =
1657 MultilibSet()
1658 .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1659 MArchDefault)
1660 .Maybe(UCLibc)
1661 .Maybe(Mips16)
1662 .FilterOut("/mips64/mips16")
1663 .FilterOut("/mips64r2/mips16")
1664 .FilterOut("/micromips/mips16")
1665 .Maybe(MAbi64)
1666 .FilterOut("/micromips/64")
1667 .FilterOut("/mips32/64")
1668 .FilterOut("^/64")
1669 .FilterOut("/mips16/64")
1670 .Either(BigEndian, LittleEndian)
1671 .Maybe(SoftFloat)
1672 .Maybe(Nan2008)
1673 .FilterOut(".*sof/nan2008")
1674 .FilterOut(NonExistent)
1675 .setIncludeDirsCallback([](StringRef InstallDir,
1676 StringRef TripleStr, const Multilib &M) {
1677 std::vector<std::string> Dirs;
1678 Dirs.push_back((InstallDir + "/include").str());
1679 std::string SysRootInc =
1680 InstallDir.str() + "/../../../../sysroot";
1681 if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1682 Dirs.push_back(SysRootInc + "/uclibc/usr/include");
1683 else
1684 Dirs.push_back(SysRootInc + "/usr/include");
1685 return Dirs;
1686 });
Simon Atanasyan13e965a2013-11-26 11:57:14 +00001687 }
1688
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001689 // Check for Code Sourcery toolchain multilibs
1690 MultilibSet CSMipsMultilibs;
1691 {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001692 auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
Simon Atanasyan13e965a2013-11-26 11:57:14 +00001693
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001694 auto MArchMicroMips =
1695 makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001696
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001697 auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001698
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001699 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00001700
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001701 auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001702
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001703 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001704
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001705 auto DefaultFloat =
1706 makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001707
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001708 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001709
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001710 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001711
1712 // Note that this one's osSuffix is ""
Simon Atanasyan1b0542e2014-07-30 09:15:10 +00001713 auto MAbi64 = makeMultilib("")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001714 .gccSuffix("/64")
1715 .includeSuffix("/64")
1716 .flag("+mabi=n64")
1717 .flag("-mabi=n32")
1718 .flag("-m32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001719
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001720 CSMipsMultilibs =
1721 MultilibSet()
1722 .Either(MArchMips16, MArchMicroMips, MArchDefault)
1723 .Maybe(UCLibc)
1724 .Either(SoftFloat, Nan2008, DefaultFloat)
1725 .FilterOut("/micromips/nan2008")
1726 .FilterOut("/mips16/nan2008")
1727 .Either(BigEndian, LittleEndian)
1728 .Maybe(MAbi64)
1729 .FilterOut("/mips16.*/64")
1730 .FilterOut("/micromips.*/64")
1731 .FilterOut(NonExistent)
1732 .setIncludeDirsCallback([](StringRef InstallDir,
1733 StringRef TripleStr, const Multilib &M) {
1734 std::vector<std::string> Dirs;
1735 Dirs.push_back((InstallDir + "/include").str());
1736 std::string SysRootInc =
1737 InstallDir.str() + "/../../../../" + TripleStr.str();
1738 if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1739 Dirs.push_back(SysRootInc + "/libc/uclibc/usr/include");
1740 else
1741 Dirs.push_back(SysRootInc + "/libc/usr/include");
1742 return Dirs;
1743 });
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001744 }
1745
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001746 MultilibSet AndroidMipsMultilibs =
1747 MultilibSet()
1748 .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1749 .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1750 .FilterOut(NonExistent);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001751
1752 MultilibSet DebianMipsMultilibs;
1753 {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001754 Multilib MAbiN32 =
1755 Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001756
1757 Multilib M64 = Multilib()
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001758 .gccSuffix("/64")
1759 .includeSuffix("/64")
1760 .flag("+m64")
1761 .flag("-m32")
1762 .flag("-mabi=n32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001763
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001764 Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001765
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001766 DebianMipsMultilibs =
1767 MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001768 }
1769
Daniel Sanders2bf13662014-07-10 14:40:57 +00001770 MultilibSet ImgMultilibs;
1771 {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001772 auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
Daniel Sanders2bf13662014-07-10 14:40:57 +00001773
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001774 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
Daniel Sanders2bf13662014-07-10 14:40:57 +00001775
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001776 auto MAbi64 =
1777 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
Daniel Sanders2bf13662014-07-10 14:40:57 +00001778
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001779 ImgMultilibs =
1780 MultilibSet()
1781 .Maybe(Mips64r6)
1782 .Maybe(MAbi64)
1783 .Maybe(LittleEndian)
1784 .FilterOut(NonExistent)
1785 .setIncludeDirsCallback([](StringRef InstallDir,
1786 StringRef TripleStr, const Multilib &M) {
1787 std::vector<std::string> Dirs;
1788 Dirs.push_back((InstallDir + "/include").str());
1789 Dirs.push_back(
1790 (InstallDir + "/../../../../sysroot/usr/include").str());
1791 return Dirs;
1792 });
Daniel Sanders2bf13662014-07-10 14:40:57 +00001793 }
1794
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001795 StringRef CPUName;
1796 StringRef ABIName;
1797 tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
1798
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001799 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1800
1801 Multilib::flags_list Flags;
1802 addMultilibFlag(isMips32(TargetArch), "m32", Flags);
1803 addMultilibFlag(isMips64(TargetArch), "m64", Flags);
1804 addMultilibFlag(isMips16(Args), "mips16", Flags);
Simon Atanasyan9988e3a2014-07-16 17:34:54 +00001805 addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
Simon Atanasyan59b25cb2015-02-26 04:45:57 +00001806 addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
Daniel Sandersff952582015-10-05 12:24:30 +00001807 CPUName == "mips32r5" || CPUName == "p5600",
Simon Atanasyan59b25cb2015-02-26 04:45:57 +00001808 "march=mips32r2", Flags);
Simon Atanasyan3f024032015-02-25 07:31:12 +00001809 addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
Simon Atanasyan9988e3a2014-07-16 17:34:54 +00001810 addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
Simon Atanasyan59b25cb2015-02-26 04:45:57 +00001811 addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
1812 CPUName == "mips64r5" || CPUName == "octeon",
Simon Atanasyan9988e3a2014-07-16 17:34:54 +00001813 "march=mips64r2", Flags);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001814 addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00001815 addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
Simon Atanasyanab6db9f2014-07-16 12:24:48 +00001816 addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
1817 Flags);
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001818 addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
1819 addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001820 addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001821 addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001822 addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001823 addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001824
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001825 if (TargetTriple.isAndroid()) {
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001826 // Select Android toolchain. It's the only choice in that case.
Simon Atanasyan60280b42014-05-12 07:37:51 +00001827 if (AndroidMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1828 Result.Multilibs = AndroidMipsMultilibs;
1829 return true;
1830 }
1831 return false;
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001832 }
1833
Daniel Sanders2bf13662014-07-10 14:40:57 +00001834 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1835 TargetTriple.getOS() == llvm::Triple::Linux &&
1836 TargetTriple.getEnvironment() == llvm::Triple::GNU) {
1837 // Select mips-img-linux-gnu toolchain.
1838 if (ImgMultilibs.select(Flags, Result.SelectedMultilib)) {
1839 Result.Multilibs = ImgMultilibs;
1840 return true;
1841 }
1842 return false;
1843 }
1844
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001845 // Sort candidates. Toolchain that best meets the directories goes first.
1846 // Then select the first toolchains matches command line flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001847 MultilibSet *candidates[] = {&DebianMipsMultilibs, &FSFMipsMultilibs,
1848 &CSMipsMultilibs};
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001849 std::sort(
1850 std::begin(candidates), std::end(candidates),
1851 [](MultilibSet *a, MultilibSet *b) { return a->size() > b->size(); });
1852 for (const auto &candidate : candidates) {
Simon Atanasyan60280b42014-05-12 07:37:51 +00001853 if (candidate->select(Flags, Result.SelectedMultilib)) {
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001854 if (candidate == &DebianMipsMultilibs)
Simon Atanasyan60280b42014-05-12 07:37:51 +00001855 Result.BiarchSibling = Multilib();
1856 Result.Multilibs = *candidate;
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001857 return true;
1858 }
1859 }
1860
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00001861 {
1862 // Fallback to the regular toolchain-tree structure.
1863 Multilib Default;
1864 Result.Multilibs.push_back(Default);
1865 Result.Multilibs.FilterOut(NonExistent);
1866
1867 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
1868 Result.BiarchSibling = Multilib();
1869 return true;
1870 }
1871 }
1872
Simon Atanasyan738f85a2014-03-04 18:37:28 +00001873 return false;
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001874}
1875
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001876static bool findBiarchMultilibs(const Driver &D,
1877 const llvm::Triple &TargetTriple,
Simon Atanasyan60280b42014-05-12 07:37:51 +00001878 StringRef Path, const ArgList &Args,
1879 bool NeedsBiarchSuffix,
1880 DetectedMultilibs &Result) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001881 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1882 // in what would normally be GCCInstallPath and put the 64-bit
1883 // libs in a subdirectory named 64. The simple logic we follow is that
1884 // *if* there is a subdirectory of the right name with crtbegin.o in it,
1885 // we use that. If not, and if not a biarch triple alias, we look for
1886 // crtbegin.o without the subdirectory.
1887
1888 Multilib Default;
1889 Multilib Alt64 = Multilib()
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001890 .gccSuffix("/64")
1891 .includeSuffix("/64")
1892 .flag("-m32")
1893 .flag("+m64")
1894 .flag("-mx32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001895 Multilib Alt32 = Multilib()
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001896 .gccSuffix("/32")
1897 .includeSuffix("/32")
1898 .flag("+m32")
1899 .flag("-m64")
1900 .flag("-mx32");
Zinovy Nis1db95732014-07-10 15:27:19 +00001901 Multilib Altx32 = Multilib()
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001902 .gccSuffix("/x32")
1903 .includeSuffix("/x32")
1904 .flag("-m32")
1905 .flag("-m64")
1906 .flag("+mx32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001907
Benjamin Kramerc5862f02015-10-09 13:03:18 +00001908 FilterNonExistent NonExistent(Path, D.getVFS());
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001909
Zinovy Nis1db95732014-07-10 15:27:19 +00001910 // Determine default multilib from: 32, 64, x32
1911 // Also handle cases such as 64 on 32, 32 on 64, etc.
1912 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
David Blaikie40f842d2014-07-10 18:46:15 +00001913 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
Alp Tokerf45fa3d2014-02-25 04:21:44 +00001914 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
Zinovy Nis1db95732014-07-10 15:27:19 +00001915 Want = WANT64;
Zinovy Nis6e3c6302014-07-10 15:42:35 +00001916 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
Zinovy Nis1db95732014-07-10 15:27:19 +00001917 Want = WANT64;
Zinovy Nis6e3c6302014-07-10 15:42:35 +00001918 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
Zinovy Nis1db95732014-07-10 15:27:19 +00001919 Want = WANT32;
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001920 else {
Zinovy Nis1db95732014-07-10 15:27:19 +00001921 if (TargetTriple.isArch32Bit())
1922 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
Zinovy Nis6e3c6302014-07-10 15:42:35 +00001923 else if (IsX32)
Zinovy Nis1db95732014-07-10 15:27:19 +00001924 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001925 else
Zinovy Nis1db95732014-07-10 15:27:19 +00001926 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
Jonathan Roelofs0e7ec602014-02-12 01:29:25 +00001927 }
1928
Zinovy Nis1db95732014-07-10 15:27:19 +00001929 if (Want == WANT32)
1930 Default.flag("+m32").flag("-m64").flag("-mx32");
1931 else if (Want == WANT64)
1932 Default.flag("-m32").flag("+m64").flag("-mx32");
1933 else if (Want == WANTX32)
1934 Default.flag("-m32").flag("-m64").flag("+mx32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001935 else
Zinovy Nis1db95732014-07-10 15:27:19 +00001936 return false;
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001937
Simon Atanasyan60280b42014-05-12 07:37:51 +00001938 Result.Multilibs.push_back(Default);
1939 Result.Multilibs.push_back(Alt64);
1940 Result.Multilibs.push_back(Alt32);
Zinovy Nis1db95732014-07-10 15:27:19 +00001941 Result.Multilibs.push_back(Altx32);
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001942
Simon Atanasyan60280b42014-05-12 07:37:51 +00001943 Result.Multilibs.FilterOut(NonExistent);
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001944
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001945 Multilib::flags_list Flags;
Zinovy Nis6e3c6302014-07-10 15:42:35 +00001946 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001947 addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
Zinovy Nis6e3c6302014-07-10 15:42:35 +00001948 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001949
Simon Atanasyan60280b42014-05-12 07:37:51 +00001950 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001951 return false;
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001952
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001953 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
Zinovy Nis1db95732014-07-10 15:27:19 +00001954 Result.SelectedMultilib == Altx32)
Simon Atanasyan60280b42014-05-12 07:37:51 +00001955 Result.BiarchSibling = Default;
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001956
1957 return true;
Simon Atanasyan08450bd2013-04-20 08:15:03 +00001958}
1959
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001960void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
1961 const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args,
1962 const std::string &LibDir, StringRef CandidateTriple,
1963 bool NeedsBiarchSuffix) {
1964 // Solaris is a special case. The GCC installation is under
1965 // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we
1966 // need to iterate twice.
1967 std::error_code EC;
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001968 for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE;
1969 !EC && LI != LE; LI = LI.increment(EC)) {
1970 StringRef VersionText = llvm::sys::path::filename(LI->getName());
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001971 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1972
1973 if (CandidateVersion.Major != -1) // Filter obviously bad entries.
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001974 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001975 continue; // Saw this path before; no need to look at it again.
1976 if (CandidateVersion.isOlderThan(4, 1, 1))
1977 continue;
1978 if (CandidateVersion <= Version)
1979 continue;
1980
1981 GCCInstallPath =
1982 LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str();
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001983 if (!D.getVFS().exists(GCCInstallPath))
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001984 continue;
1985
1986 // If we make it here there has to be at least one GCC version, let's just
1987 // use the latest one.
1988 std::error_code EEC;
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001989 for (vfs::directory_iterator
1990 LLI = D.getVFS().dir_begin(GCCInstallPath, EEC),
1991 LLE;
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001992 !EEC && LLI != LLE; LLI = LLI.increment(EEC)) {
1993
Benjamin Kramerd45b2052015-10-07 15:48:01 +00001994 StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
Rafael Espindolac53c5b12015-08-31 19:17:51 +00001995 GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText);
1996
1997 if (CandidateSubVersion > Version)
1998 Version = CandidateSubVersion;
1999 }
2000
2001 GCCTriple.setTriple(CandidateTriple);
2002
2003 GCCInstallPath += "/" + Version.Text;
2004 GCCParentLibPath = GCCInstallPath + "/../../../../";
2005
2006 IsValid = true;
2007 }
2008}
2009
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002010void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00002011 const llvm::Triple &TargetTriple, const ArgList &Args,
Chandler Carruthb427c562013-06-22 11:35:51 +00002012 const std::string &LibDir, StringRef CandidateTriple,
2013 bool NeedsBiarchSuffix) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00002014 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002015 // There are various different suffixes involving the triple we
2016 // check for. We also record what is necessary to walk from each back
Douglas Katzmancb07d152015-08-14 15:52:12 +00002017 // up to the lib directory. Specifically, the number of "up" steps
2018 // in the second half of each row is 1 + the number of path separators
2019 // in the first half.
2020 const std::string LibAndInstallSuffixes[][2] = {
2021 {"/gcc/" + CandidateTriple.str(), "/../../.."},
2022
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002023 // Debian puts cross-compilers in gcc-cross
Douglas Katzmancb07d152015-08-14 15:52:12 +00002024 {"/gcc-cross/" + CandidateTriple.str(), "/../../.."},
2025
2026 {"/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
2027 "/../../../.."},
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002028
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002029 // The Freescale PPC SDK has the gcc libraries in
2030 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
Douglas Katzmancb07d152015-08-14 15:52:12 +00002031 {"/" + CandidateTriple.str(), "/../.."},
Hal Finkelf3587912012-09-18 22:25:07 +00002032
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002033 // Ubuntu has a strange mis-matched pair of triples that this happens to
2034 // match.
2035 // FIXME: It may be worthwhile to generalize this and look for a second
2036 // triple.
Douglas Katzmancb07d152015-08-14 15:52:12 +00002037 {"/i386-linux-gnu/gcc/" + CandidateTriple.str(), "/../../../.."}};
2038
Rafael Espindolac53c5b12015-08-31 19:17:51 +00002039 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2040 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
2041 NeedsBiarchSuffix);
2042 return;
2043 }
2044
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002045 // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
Douglas Katzmancb07d152015-08-14 15:52:12 +00002046 const unsigned NumLibSuffixes = (llvm::array_lengthof(LibAndInstallSuffixes) -
2047 (TargetArch != llvm::Triple::x86));
Chandler Carruth866faab2012-01-25 07:21:38 +00002048 for (unsigned i = 0; i < NumLibSuffixes; ++i) {
Douglas Katzmancb07d152015-08-14 15:52:12 +00002049 StringRef LibSuffix = LibAndInstallSuffixes[i][0];
Rafael Espindolac0809172014-06-12 14:02:15 +00002050 std::error_code EC;
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002051 for (vfs::directory_iterator
2052 LI = D.getVFS().dir_begin(LibDir + LibSuffix, EC),
2053 LE;
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002054 !EC && LI != LE; LI = LI.increment(EC)) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002055 StringRef VersionText = llvm::sys::path::filename(LI->getName());
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002056 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
Benjamin Kramera97e4d12013-08-14 18:38:51 +00002057 if (CandidateVersion.Major != -1) // Filter obviously bad entries.
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002058 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
Benjamin Kramera97e4d12013-08-14 18:38:51 +00002059 continue; // Saw this path before; no need to look at it again.
Benjamin Kramer604e8482013-08-09 17:17:48 +00002060 if (CandidateVersion.isOlderThan(4, 1, 1))
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002061 continue;
2062 if (CandidateVersion <= Version)
2063 continue;
Hal Finkel221e11e2011-12-08 05:50:03 +00002064
Simon Atanasyan60280b42014-05-12 07:37:51 +00002065 DetectedMultilibs Detected;
Simon Atanasyanee1accf2013-09-28 13:45:11 +00002066
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00002067 // Debian mips multilibs behave more like the rest of the biarch ones,
2068 // so handle them there
2069 if (isMipsArch(TargetArch)) {
Benjamin Kramerc5862f02015-10-09 13:03:18 +00002070 if (!findMIPSMultilibs(D, TargetTriple, LI->getName(), Args, Detected))
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00002071 continue;
Benjamin Kramerc5862f02015-10-09 13:03:18 +00002072 } else if (!findBiarchMultilibs(D, TargetTriple, LI->getName(), Args,
Simon Atanasyan60280b42014-05-12 07:37:51 +00002073 NeedsBiarchSuffix, Detected)) {
Simon Atanasyanee1accf2013-09-28 13:45:11 +00002074 continue;
Simon Atanasyan60280b42014-05-12 07:37:51 +00002075 }
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002076
Simon Atanasyan60280b42014-05-12 07:37:51 +00002077 Multilibs = Detected.Multilibs;
2078 SelectedMultilib = Detected.SelectedMultilib;
2079 BiarchSibling = Detected.BiarchSibling;
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002080 Version = CandidateVersion;
Chandler Carruth4d9d7682012-01-24 19:28:29 +00002081 GCCTriple.setTriple(CandidateTriple);
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002082 // FIXME: We hack together the directory name here instead of
2083 // using LI to ensure stable path separators across Windows and
2084 // Linux.
Douglas Katzmancb07d152015-08-14 15:52:12 +00002085 GCCInstallPath =
2086 LibDir + LibAndInstallSuffixes[i][0] + "/" + VersionText.str();
2087 GCCParentLibPath = GCCInstallPath + LibAndInstallSuffixes[i][1];
Chandler Carruth4c90fba2011-11-06 23:39:34 +00002088 IsValid = true;
2089 }
2090 }
2091}
2092
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002093Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola1af7c212012-02-19 01:38:32 +00002094 const ArgList &Args)
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002095 : ToolChain(D, Triple, Args), GCCInstallation(D), CudaInstallation(D) {
Daniel Dunbar88979912010-08-01 22:29:51 +00002096 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer51477bd2011-03-01 22:50:47 +00002097 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbar88979912010-08-01 22:29:51 +00002098 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbar76ce7412009-03-23 16:15:50 +00002099}
2100
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00002101Generic_GCC::~Generic_GCC() {}
Daniel Dunbar59e5e882009-03-20 00:20:03 +00002102
Rafael Espindola7cf32212013-03-20 03:05:54 +00002103Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
Rafael Espindola260e28d2013-03-18 20:48:54 +00002104 switch (AC) {
Rafael Espindolac8e3a012013-03-18 18:50:01 +00002105 case Action::PreprocessJobClass:
Rafael Espindola7cf32212013-03-20 03:05:54 +00002106 if (!Preprocess)
Douglas Katzman95354292015-06-23 20:42:09 +00002107 Preprocess.reset(new tools::gcc::Preprocessor(*this));
Rafael Espindola7cf32212013-03-20 03:05:54 +00002108 return Preprocess.get();
Rafael Espindolac8e3a012013-03-18 18:50:01 +00002109 case Action::CompileJobClass:
Rafael Espindola7cf32212013-03-20 03:05:54 +00002110 if (!Compile)
Douglas Katzman95354292015-06-23 20:42:09 +00002111 Compile.reset(new tools::gcc::Compiler(*this));
Rafael Espindola7cf32212013-03-20 03:05:54 +00002112 return Compile.get();
Rafael Espindolad15a8912013-03-19 00:36:57 +00002113 default:
Rafael Espindola7cf32212013-03-20 03:05:54 +00002114 return ToolChain::getTool(AC);
Daniel Dunbar59e5e882009-03-20 00:20:03 +00002115 }
Daniel Dunbar59e5e882009-03-20 00:20:03 +00002116}
2117
Rafael Espindola7cf32212013-03-20 03:05:54 +00002118Tool *Generic_GCC::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002119 return new tools::gnutools::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002120}
2121
Douglas Katzman95354292015-06-23 20:42:09 +00002122Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
Rafael Espindola7cf32212013-03-20 03:05:54 +00002123
Chandler Carruth0ae39aa2013-07-30 17:57:09 +00002124void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2125 // Print the information about how we detected the GCC installation.
2126 GCCInstallation.print(OS);
Artem Belevich98607b62015-09-23 21:49:39 +00002127 CudaInstallation.print(OS);
Chandler Carruth0ae39aa2013-07-30 17:57:09 +00002128}
2129
Daniel Dunbar59e5e882009-03-20 00:20:03 +00002130bool Generic_GCC::IsUnwindTablesDefault() const {
Rafael Espindola08f1ebb2012-09-22 15:04:11 +00002131 return getArch() == llvm::Triple::x86_64;
Daniel Dunbar59e5e882009-03-20 00:20:03 +00002132}
2133
David Majnemer17f448b2015-06-28 04:23:33 +00002134bool Generic_GCC::isPICDefault() const {
2135 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2136}
Daniel Dunbar59e5e882009-03-20 00:20:03 +00002137
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002138bool Generic_GCC::isPIEDefault() const { return false; }
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002139
David Majnemer17f448b2015-06-28 04:23:33 +00002140bool Generic_GCC::isPICDefaultForced() const {
2141 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2142}
Chandler Carruth76a943b2012-11-19 03:52:03 +00002143
Rafael Espindolaa8b3b682013-11-25 18:50:53 +00002144bool Generic_GCC::IsIntegratedAssemblerDefault() const {
Douglas Katzman7ae27b82015-06-03 19:40:30 +00002145 switch (getTriple().getArch()) {
2146 case llvm::Triple::x86:
2147 case llvm::Triple::x86_64:
2148 case llvm::Triple::aarch64:
2149 case llvm::Triple::aarch64_be:
2150 case llvm::Triple::arm:
2151 case llvm::Triple::armeb:
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00002152 case llvm::Triple::bpfel:
2153 case llvm::Triple::bpfeb:
Douglas Katzman7ae27b82015-06-03 19:40:30 +00002154 case llvm::Triple::thumb:
2155 case llvm::Triple::thumbeb:
2156 case llvm::Triple::ppc:
2157 case llvm::Triple::ppc64:
2158 case llvm::Triple::ppc64le:
2159 case llvm::Triple::sparc:
2160 case llvm::Triple::sparcel:
2161 case llvm::Triple::sparcv9:
2162 case llvm::Triple::systemz:
2163 return true;
2164 default:
2165 return false;
2166 }
Rafael Espindolaa8b3b682013-11-25 18:50:53 +00002167}
2168
James Y Knighta6c9ee72015-10-16 18:46:26 +00002169/// \brief Helper to add the variant paths of a libstdc++ installation.
2170bool Generic_GCC::addLibStdCXXIncludePaths(
2171 Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2172 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2173 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2174 if (!getVFS().exists(Base + Suffix))
2175 return false;
2176
2177 addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2178
2179 // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2180 // that path exists or we have neither a GCC nor target multiarch triple, use
2181 // this vanilla search path.
2182 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2183 getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2184 addSystemInclude(DriverArgs, CC1Args,
2185 Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2186 } else {
2187 // Otherwise try to use multiarch naming schemes which have normalized the
2188 // triples and put the triple before the suffix.
2189 //
2190 // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2191 // the target triple, so we support that here.
2192 addSystemInclude(DriverArgs, CC1Args,
2193 Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2194 addSystemInclude(DriverArgs, CC1Args,
2195 Base + "/" + TargetMultiarchTriple + Suffix);
2196 }
2197
2198 addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2199 return true;
2200}
2201
2202
Kristof Beylsfb387292014-01-10 13:44:34 +00002203void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
2204 ArgStringList &CC1Args) const {
2205 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
Tim Northovera2ee4332014-03-29 15:09:45 +00002206 bool UseInitArrayDefault =
Kristof Beylsfb387292014-01-10 13:44:34 +00002207 getTriple().getArch() == llvm::Triple::aarch64 ||
Christian Pirker9b019ae2014-02-25 13:51:00 +00002208 getTriple().getArch() == llvm::Triple::aarch64_be ||
Tim Northovera2ee4332014-03-29 15:09:45 +00002209 (getTriple().getOS() == llvm::Triple::Linux &&
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00002210 (!V.isOlderThan(4, 7, 0) || getTriple().isAndroid())) ||
Vasileios Kalintirisfdfc0102015-10-05 10:34:46 +00002211 getTriple().getOS() == llvm::Triple::NaCl;
Kristof Beylsfb387292014-01-10 13:44:34 +00002212
2213 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002214 options::OPT_fno_use_init_array, UseInitArrayDefault))
Kristof Beylsfb387292014-01-10 13:44:34 +00002215 CC1Args.push_back("-fuse-init-array");
2216}
2217
Tony Linthicum76329bf2011-12-12 21:14:55 +00002218/// Hexagon Toolchain
2219
Douglas Katzman54366072015-07-27 16:53:08 +00002220std::string HexagonToolChain::GetGnuDir(const std::string &InstalledDir,
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002221 const ArgList &Args) const {
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002222 // Locate the rest of the toolchain ...
Samuel Antaoc909c992014-11-07 17:48:03 +00002223 std::string GccToolchain = getGCCToolchainDir(Args);
2224
2225 if (!GccToolchain.empty())
2226 return GccToolchain;
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002227
2228 std::string InstallRelDir = InstalledDir + "/../../gnu";
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002229 if (getVFS().exists(InstallRelDir))
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002230 return InstallRelDir;
2231
2232 std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002233 if (getVFS().exists(PrefixRelDir))
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002234 return PrefixRelDir;
2235
2236 return InstallRelDir;
2237}
2238
Douglas Katzman54366072015-07-27 16:53:08 +00002239const char *HexagonToolChain::GetSmallDataThreshold(const ArgList &Args) {
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00002240 Arg *A;
2241
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002242 A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ,
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00002243 options::OPT_msmall_data_threshold_EQ);
2244 if (A)
2245 return A->getValue();
2246
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002247 A = Args.getLastArg(options::OPT_shared, options::OPT_fpic,
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00002248 options::OPT_fPIC);
2249 if (A)
2250 return "0";
2251
Hans Wennborgdcfba332015-10-06 23:40:43 +00002252 return nullptr;
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00002253}
2254
Douglas Katzman54366072015-07-27 16:53:08 +00002255bool HexagonToolChain::UsesG0(const char *smallDataThreshold) {
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00002256 return smallDataThreshold && smallDataThreshold[0] == '0';
2257}
2258
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002259static void GetHexagonLibraryPaths(const HexagonToolChain &TC,
2260 const ArgList &Args, const std::string &Ver,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002261 const std::string &MarchString,
2262 const std::string &InstalledDir,
2263 ToolChain::path_list *LibPaths) {
Matthew Curtise689b052012-12-06 15:46:07 +00002264 bool buildingLib = Args.hasArg(options::OPT_shared);
2265
2266 //----------------------------------------------------------------------------
2267 // -L Args
2268 //----------------------------------------------------------------------------
Douglas Katzman6bbffc42015-06-25 18:51:37 +00002269 for (Arg *A : Args.filtered(options::OPT_L))
2270 for (const char *Value : A->getValues())
2271 LibPaths->push_back(Value);
Matthew Curtise689b052012-12-06 15:46:07 +00002272
2273 //----------------------------------------------------------------------------
2274 // Other standard paths
2275 //----------------------------------------------------------------------------
2276 const std::string MarchSuffix = "/" + MarchString;
2277 const std::string G0Suffix = "/G0";
2278 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002279 const std::string RootDir = TC.GetGnuDir(InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00002280
2281 // lib/gcc/hexagon/...
2282 std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
2283 if (buildingLib) {
2284 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
2285 LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
2286 }
2287 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
2288 LibPaths->push_back(LibGCCHexagonDir + Ver);
2289
2290 // lib/gcc/...
2291 LibPaths->push_back(RootDir + "lib/gcc");
2292
2293 // hexagon/lib/...
2294 std::string HexagonLibDir = RootDir + "hexagon/lib";
2295 if (buildingLib) {
2296 LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
2297 LibPaths->push_back(HexagonLibDir + G0Suffix);
2298 }
2299 LibPaths->push_back(HexagonLibDir + MarchSuffix);
2300 LibPaths->push_back(HexagonLibDir);
2301}
2302
Douglas Katzman54366072015-07-27 16:53:08 +00002303HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
2304 const ArgList &Args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002305 : Linux(D, Triple, Args) {
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002306 const std::string InstalledDir(getDriver().getInstalledDir());
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002307 const std::string GnuDir = GetGnuDir(InstalledDir, Args);
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002308
2309 // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
2310 // program paths
2311 const std::string BinDir(GnuDir + "/bin");
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002312 if (D.getVFS().exists(BinDir))
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002313 getProgramPaths().push_back(BinDir);
2314
2315 // Determine version of GCC libraries and headers to use.
2316 const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
Rafael Espindolac0809172014-06-12 14:02:15 +00002317 std::error_code ec;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002318 GCCVersion MaxVersion = GCCVersion::Parse("0.0.0");
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002319 for (vfs::directory_iterator di = D.getVFS().dir_begin(HexagonDir, ec), de;
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002320 !ec && di != de; di = di.increment(ec)) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002321 GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->getName()));
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002322 if (MaxVersion < cv)
2323 MaxVersion = cv;
2324 }
2325 GCCLibAndIncVersion = MaxVersion;
Matthew Curtise689b052012-12-06 15:46:07 +00002326
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002327 ToolChain::path_list *LibPaths = &getFilePaths();
Matthew Curtise689b052012-12-06 15:46:07 +00002328
2329 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
2330 // 'elf' OS type, so the Linux paths are not appropriate. When we actually
2331 // support 'linux' we'll need to fix this up
2332 LibPaths->clear();
2333
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002334 GetHexagonLibraryPaths(*this, Args, GetGCCLibAndIncVersion(),
2335 GetTargetCPU(Args), InstalledDir, LibPaths);
Tony Linthicum76329bf2011-12-12 21:14:55 +00002336}
2337
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00002338HexagonToolChain::~HexagonToolChain() {}
Tony Linthicum76329bf2011-12-12 21:14:55 +00002339
Douglas Katzman54366072015-07-27 16:53:08 +00002340Tool *HexagonToolChain::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002341 return new tools::hexagon::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002342}
2343
Douglas Katzman54366072015-07-27 16:53:08 +00002344Tool *HexagonToolChain::buildLinker() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002345 return new tools::hexagon::Linker(*this);
Tony Linthicum76329bf2011-12-12 21:14:55 +00002346}
2347
Douglas Katzman54366072015-07-27 16:53:08 +00002348void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2349 ArgStringList &CC1Args) const {
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002350 const Driver &D = getDriver();
2351
2352 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2353 DriverArgs.hasArg(options::OPT_nostdlibinc))
2354 return;
2355
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002356 std::string Ver(GetGCCLibAndIncVersion());
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002357 std::string GnuDir = GetGnuDir(D.InstalledDir, DriverArgs);
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002358 std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
2359 addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
2360 addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
2361 addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
Tony Linthicum76329bf2011-12-12 21:14:55 +00002362}
2363
Douglas Katzman54366072015-07-27 16:53:08 +00002364void HexagonToolChain::AddClangCXXStdlibIncludeArgs(
2365 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002366 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2367 DriverArgs.hasArg(options::OPT_nostdincxx))
2368 return;
2369
2370 const Driver &D = getDriver();
2371 std::string Ver(GetGCCLibAndIncVersion());
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002372 SmallString<128> IncludeDir(GetGnuDir(D.InstalledDir, DriverArgs));
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002373
Rafael Espindola358256c2013-06-26 02:13:00 +00002374 llvm::sys::path::append(IncludeDir, "hexagon/include/c++/");
2375 llvm::sys::path::append(IncludeDir, Ver);
Yaron Keren92e1b622015-03-18 10:17:07 +00002376 addSystemInclude(DriverArgs, CC1Args, IncludeDir);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002377}
Matthew Curtisf10a5952012-12-06 14:16:43 +00002378
Matthew Curtise689b052012-12-06 15:46:07 +00002379ToolChain::CXXStdlibType
Douglas Katzman54366072015-07-27 16:53:08 +00002380HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
Matthew Curtise689b052012-12-06 15:46:07 +00002381 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2382 if (!A)
2383 return ToolChain::CST_Libstdcxx;
2384
2385 StringRef Value = A->getValue();
2386 if (Value != "libstdc++") {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002387 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
Matthew Curtise689b052012-12-06 15:46:07 +00002388 }
2389
2390 return ToolChain::CST_Libstdcxx;
2391}
2392
Rafael Espindolabfd88f22013-09-24 13:28:24 +00002393static int getHexagonVersion(const ArgList &Args) {
2394 Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ);
2395 // Select the default CPU (v4) if none was given.
2396 if (!A)
2397 return 4;
Matthew Curtisf10a5952012-12-06 14:16:43 +00002398
Rafael Espindolabfd88f22013-09-24 13:28:24 +00002399 // FIXME: produce errors if we cannot parse the version.
2400 StringRef WhichHexagon = A->getValue();
2401 if (WhichHexagon.startswith("hexagonv")) {
2402 int Val;
2403 if (!WhichHexagon.substr(sizeof("hexagonv") - 1).getAsInteger(10, Val))
2404 return Val;
Matthew Curtisf10a5952012-12-06 14:16:43 +00002405 }
Rafael Espindolabfd88f22013-09-24 13:28:24 +00002406 if (WhichHexagon.startswith("v")) {
2407 int Val;
2408 if (!WhichHexagon.substr(1).getAsInteger(10, Val))
2409 return Val;
2410 }
2411
2412 // FIXME: should probably be an error.
2413 return 4;
Matthew Curtisf10a5952012-12-06 14:16:43 +00002414}
2415
Douglas Katzman54366072015-07-27 16:53:08 +00002416StringRef HexagonToolChain::GetTargetCPU(const ArgList &Args) {
Rafael Espindolabfd88f22013-09-24 13:28:24 +00002417 int V = getHexagonVersion(Args);
2418 // FIXME: We don't support versions < 4. We should error on them.
2419 switch (V) {
2420 default:
2421 llvm_unreachable("Unexpected version");
2422 case 5:
2423 return "v5";
2424 case 4:
2425 return "v4";
2426 case 3:
2427 return "v3";
2428 case 2:
2429 return "v2";
2430 case 1:
2431 return "v1";
Matthew Curtisf10a5952012-12-06 14:16:43 +00002432 }
Matthew Curtisf10a5952012-12-06 14:16:43 +00002433}
Matthew Curtis22dd8da2012-12-06 12:43:18 +00002434// End Hexagon
Daniel Dunbardac54a82009-03-25 04:13:45 +00002435
Tom Stellard8fa33092015-07-18 01:49:05 +00002436/// AMDGPU Toolchain
2437AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
2438 const ArgList &Args)
2439 : Generic_ELF(D, Triple, Args) { }
2440
2441Tool *AMDGPUToolChain::buildLinker() const {
2442 return new tools::amdgpu::Linker(*this);
2443}
2444// End AMDGPU
2445
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002446/// NaCl Toolchain
Douglas Katzman54366072015-07-27 16:53:08 +00002447NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
2448 const ArgList &Args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002449 : Generic_ELF(D, Triple, Args) {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002450
2451 // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
2452 // default paths, and must instead only use the paths provided
2453 // with this toolchain based on architecture.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002454 path_list &file_paths = getFilePaths();
2455 path_list &prog_paths = getProgramPaths();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002456
2457 file_paths.clear();
2458 prog_paths.clear();
2459
2460 // Path for library files (libc.a, ...)
2461 std::string FilePath(getDriver().Dir + "/../");
2462
2463 // Path for tools (clang, ld, etc..)
2464 std::string ProgPath(getDriver().Dir + "/../");
2465
2466 // Path for toolchain libraries (libgcc.a, ...)
2467 std::string ToolPath(getDriver().ResourceDir + "/lib/");
2468
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002469 switch (Triple.getArch()) {
Hans Wennborgdcfba332015-10-06 23:40:43 +00002470 case llvm::Triple::x86:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002471 file_paths.push_back(FilePath + "x86_64-nacl/lib32");
Derek Schuff9afb0502015-08-26 17:14:08 +00002472 file_paths.push_back(FilePath + "i686-nacl/usr/lib");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002473 prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
2474 file_paths.push_back(ToolPath + "i686-nacl");
2475 break;
Hans Wennborgdcfba332015-10-06 23:40:43 +00002476 case llvm::Triple::x86_64:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002477 file_paths.push_back(FilePath + "x86_64-nacl/lib");
2478 file_paths.push_back(FilePath + "x86_64-nacl/usr/lib");
2479 prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
2480 file_paths.push_back(ToolPath + "x86_64-nacl");
2481 break;
Hans Wennborgdcfba332015-10-06 23:40:43 +00002482 case llvm::Triple::arm:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002483 file_paths.push_back(FilePath + "arm-nacl/lib");
2484 file_paths.push_back(FilePath + "arm-nacl/usr/lib");
2485 prog_paths.push_back(ProgPath + "arm-nacl/bin");
2486 file_paths.push_back(ToolPath + "arm-nacl");
2487 break;
Hans Wennborgdcfba332015-10-06 23:40:43 +00002488 case llvm::Triple::mipsel:
Petar Jovanovic26a4a402015-07-08 13:07:31 +00002489 file_paths.push_back(FilePath + "mipsel-nacl/lib");
2490 file_paths.push_back(FilePath + "mipsel-nacl/usr/lib");
2491 prog_paths.push_back(ProgPath + "bin");
2492 file_paths.push_back(ToolPath + "mipsel-nacl");
2493 break;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002494 default:
2495 break;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002496 }
2497
2498 // Use provided linker, not system linker
Derek Schuffef465d72015-08-24 23:53:25 +00002499 Linker = GetLinkerPath();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002500 NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
2501}
2502
Douglas Katzman54366072015-07-27 16:53:08 +00002503void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2504 ArgStringList &CC1Args) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002505 const Driver &D = getDriver();
2506 if (DriverArgs.hasArg(options::OPT_nostdinc))
2507 return;
2508
2509 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2510 SmallString<128> P(D.ResourceDir);
2511 llvm::sys::path::append(P, "include");
2512 addSystemInclude(DriverArgs, CC1Args, P.str());
2513 }
2514
2515 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2516 return;
2517
2518 SmallString<128> P(D.Dir + "/../");
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002519 switch (getTriple().getArch()) {
Derek Schuff9afb0502015-08-26 17:14:08 +00002520 case llvm::Triple::x86:
2521 // x86 is special because multilib style uses x86_64-nacl/include for libc
2522 // headers but the SDK wants i686-nacl/usr/include. The other architectures
2523 // have the same substring.
2524 llvm::sys::path::append(P, "i686-nacl/usr/include");
2525 addSystemInclude(DriverArgs, CC1Args, P.str());
2526 llvm::sys::path::remove_filename(P);
2527 llvm::sys::path::remove_filename(P);
2528 llvm::sys::path::remove_filename(P);
2529 llvm::sys::path::append(P, "x86_64-nacl/include");
2530 addSystemInclude(DriverArgs, CC1Args, P.str());
2531 return;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002532 case llvm::Triple::arm:
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002533 llvm::sys::path::append(P, "arm-nacl/usr/include");
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002534 break;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002535 case llvm::Triple::x86_64:
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002536 llvm::sys::path::append(P, "x86_64-nacl/usr/include");
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002537 break;
Petar Jovanovic26a4a402015-07-08 13:07:31 +00002538 case llvm::Triple::mipsel:
2539 llvm::sys::path::append(P, "mipsel-nacl/usr/include");
2540 break;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002541 default:
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002542 return;
2543 }
2544
2545 addSystemInclude(DriverArgs, CC1Args, P.str());
2546 llvm::sys::path::remove_filename(P);
2547 llvm::sys::path::remove_filename(P);
2548 llvm::sys::path::append(P, "include");
2549 addSystemInclude(DriverArgs, CC1Args, P.str());
2550}
2551
Douglas Katzman54366072015-07-27 16:53:08 +00002552void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
2553 ArgStringList &CmdArgs) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002554 // Check for -stdlib= flags. We only support libc++ but this consumes the arg
2555 // if the value is libc++, and emits an error for other values.
2556 GetCXXStdlibType(Args);
2557 CmdArgs.push_back("-lc++");
2558}
2559
Douglas Katzman54366072015-07-27 16:53:08 +00002560void NaClToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2561 ArgStringList &CC1Args) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002562 const Driver &D = getDriver();
2563 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2564 DriverArgs.hasArg(options::OPT_nostdincxx))
2565 return;
2566
2567 // Check for -stdlib= flags. We only support libc++ but this consumes the arg
2568 // if the value is libc++, and emits an error for other values.
2569 GetCXXStdlibType(DriverArgs);
2570
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002571 SmallString<128> P(D.Dir + "/../");
2572 switch (getTriple().getArch()) {
2573 case llvm::Triple::arm:
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002574 llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
2575 addSystemInclude(DriverArgs, CC1Args, P.str());
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002576 break;
2577 case llvm::Triple::x86:
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002578 llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
2579 addSystemInclude(DriverArgs, CC1Args, P.str());
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002580 break;
2581 case llvm::Triple::x86_64:
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002582 llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
2583 addSystemInclude(DriverArgs, CC1Args, P.str());
Douglas Katzman7e37afb2015-06-23 03:02:39 +00002584 break;
Petar Jovanovic26a4a402015-07-08 13:07:31 +00002585 case llvm::Triple::mipsel:
2586 llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
2587 addSystemInclude(DriverArgs, CC1Args, P.str());
2588 break;
Douglas Katzman9ad0ec22015-06-23 04:20:44 +00002589 default:
2590 break;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002591 }
2592}
2593
Douglas Katzman54366072015-07-27 16:53:08 +00002594ToolChain::CXXStdlibType
2595NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002596 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2597 StringRef Value = A->getValue();
2598 if (Value == "libc++")
2599 return ToolChain::CST_Libcxx;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002600 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002601 }
2602
2603 return ToolChain::CST_Libcxx;
2604}
2605
Douglas Katzman54366072015-07-27 16:53:08 +00002606std::string
2607NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
2608 types::ID InputType) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002609 llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
2610 if (TheTriple.getArch() == llvm::Triple::arm &&
2611 TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2612 TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
2613 return TheTriple.getTriple();
2614}
2615
Douglas Katzman54366072015-07-27 16:53:08 +00002616Tool *NaClToolChain::buildLinker() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002617 return new tools::nacltools::Linker(*this);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002618}
2619
Douglas Katzman54366072015-07-27 16:53:08 +00002620Tool *NaClToolChain::buildAssembler() const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002621 if (getTriple().getArch() == llvm::Triple::arm)
Douglas Katzman95354292015-06-23 20:42:09 +00002622 return new tools::nacltools::AssemblerARM(*this);
2623 return new tools::gnutools::Assembler(*this);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002624}
2625// End NaCl
2626
Chris Lattner09797542010-03-04 21:07:38 +00002627/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
2628/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
2629/// Currently does not support anything else but compilation.
2630
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002631TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola84b588b2013-03-18 18:10:27 +00002632 const ArgList &Args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002633 : ToolChain(D, Triple, Args) {
Chris Lattner09797542010-03-04 21:07:38 +00002634 // Path mangling to find libexec
2635 std::string Path(getDriver().Dir);
2636
2637 Path += "/../libexec";
2638 getProgramPaths().push_back(Path);
2639}
2640
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00002641TCEToolChain::~TCEToolChain() {}
Chris Lattner09797542010-03-04 21:07:38 +00002642
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002643bool TCEToolChain::IsMathErrnoDefault() const { return true; }
Chris Lattner09797542010-03-04 21:07:38 +00002644
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002645bool TCEToolChain::isPICDefault() const { return false; }
Chris Lattner09797542010-03-04 21:07:38 +00002646
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002647bool TCEToolChain::isPIEDefault() const { return false; }
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002648
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002649bool TCEToolChain::isPICDefaultForced() const { return false; }
Chris Lattner09797542010-03-04 21:07:38 +00002650
Ed Schouten3c3e58c2015-03-26 11:13:44 +00002651// CloudABI - CloudABI tool chain which can call ld(1) directly.
2652
2653CloudABI::CloudABI(const Driver &D, const llvm::Triple &Triple,
2654 const ArgList &Args)
2655 : Generic_ELF(D, Triple, Args) {
2656 SmallString<128> P(getDriver().Dir);
2657 llvm::sys::path::append(P, "..", getTriple().str(), "lib");
2658 getFilePaths().push_back(P.str());
2659}
2660
2661void CloudABI::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2662 ArgStringList &CC1Args) const {
2663 if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
2664 DriverArgs.hasArg(options::OPT_nostdincxx))
2665 return;
2666
2667 SmallString<128> P(getDriver().Dir);
2668 llvm::sys::path::append(P, "..", getTriple().str(), "include/c++/v1");
2669 addSystemInclude(DriverArgs, CC1Args, P.str());
2670}
2671
2672void CloudABI::AddCXXStdlibLibArgs(const ArgList &Args,
2673 ArgStringList &CmdArgs) const {
2674 CmdArgs.push_back("-lc++");
2675 CmdArgs.push_back("-lc++abi");
2676 CmdArgs.push_back("-lunwind");
2677}
2678
Douglas Katzman95354292015-06-23 20:42:09 +00002679Tool *CloudABI::buildLinker() const {
2680 return new tools::cloudabi::Linker(*this);
2681}
Ed Schouten3c3e58c2015-03-26 11:13:44 +00002682
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002683/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
2684
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002685OpenBSD::OpenBSD(const Driver &D, const llvm::Triple &Triple,
2686 const ArgList &Args)
2687 : Generic_ELF(D, Triple, Args) {
Daniel Dunbar083edf72009-12-21 18:54:17 +00002688 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002689 getFilePaths().push_back("/usr/lib");
2690}
2691
Rafael Espindola7cf32212013-03-20 03:05:54 +00002692Tool *OpenBSD::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002693 return new tools::openbsd::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002694}
2695
Douglas Katzman95354292015-06-23 20:42:09 +00002696Tool *OpenBSD::buildLinker() const { return new tools::openbsd::Linker(*this); }
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002697
Eli Friedman9fa28852012-08-08 23:57:20 +00002698/// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
2699
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002700Bitrig::Bitrig(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2701 : Generic_ELF(D, Triple, Args) {
Eli Friedman9fa28852012-08-08 23:57:20 +00002702 getFilePaths().push_back(getDriver().Dir + "/../lib");
2703 getFilePaths().push_back("/usr/lib");
2704}
2705
Rafael Espindola7cf32212013-03-20 03:05:54 +00002706Tool *Bitrig::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002707 return new tools::bitrig::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002708}
2709
Douglas Katzman95354292015-06-23 20:42:09 +00002710Tool *Bitrig::buildLinker() const { return new tools::bitrig::Linker(*this); }
Eli Friedman9fa28852012-08-08 23:57:20 +00002711
Douglas Katzman95354292015-06-23 20:42:09 +00002712ToolChain::CXXStdlibType Bitrig::GetCXXStdlibType(const ArgList &Args) const {
Richard Smith51af5192014-05-01 23:24:24 +00002713 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2714 StringRef Value = A->getValue();
2715 if (Value == "libstdc++")
2716 return ToolChain::CST_Libstdcxx;
2717 if (Value == "libc++")
2718 return ToolChain::CST_Libcxx;
2719
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002720 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
Richard Smith51af5192014-05-01 23:24:24 +00002721 }
2722 return ToolChain::CST_Libcxx;
2723}
2724
Eli Friedman9fa28852012-08-08 23:57:20 +00002725void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2726 ArgStringList &CC1Args) const {
2727 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2728 DriverArgs.hasArg(options::OPT_nostdincxx))
2729 return;
2730
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002731 switch (GetCXXStdlibType(DriverArgs)) {
2732 case ToolChain::CST_Libcxx:
2733 addSystemInclude(DriverArgs, CC1Args,
Richard Smith51af5192014-05-01 23:24:24 +00002734 getDriver().SysRoot + "/usr/include/c++/v1");
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002735 break;
2736 case ToolChain::CST_Libstdcxx:
2737 addSystemInclude(DriverArgs, CC1Args,
2738 getDriver().SysRoot + "/usr/include/c++/stdc++");
2739 addSystemInclude(DriverArgs, CC1Args,
2740 getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
Eli Friedman9fa28852012-08-08 23:57:20 +00002741
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002742 StringRef Triple = getTriple().str();
2743 if (Triple.startswith("amd64"))
2744 addSystemInclude(DriverArgs, CC1Args,
2745 getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002746 Triple.substr(5));
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002747 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002748 addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot +
2749 "/usr/include/c++/stdc++/" +
2750 Triple);
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002751 break;
2752 }
Eli Friedman9fa28852012-08-08 23:57:20 +00002753}
2754
2755void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
2756 ArgStringList &CmdArgs) const {
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002757 switch (GetCXXStdlibType(Args)) {
2758 case ToolChain::CST_Libcxx:
2759 CmdArgs.push_back("-lc++");
Richard Smith51af5192014-05-01 23:24:24 +00002760 CmdArgs.push_back("-lc++abi");
2761 CmdArgs.push_back("-lpthread");
Chandler Carruthc0f5cd12012-10-08 21:31:38 +00002762 break;
2763 case ToolChain::CST_Libstdcxx:
2764 CmdArgs.push_back("-lstdc++");
2765 break;
2766 }
Eli Friedman9fa28852012-08-08 23:57:20 +00002767}
2768
Daniel Dunbare24297c2009-03-30 21:06:03 +00002769/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
2770
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002771FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple,
2772 const ArgList &Args)
2773 : Generic_ELF(D, Triple, Args) {
Daniel Dunbara18a4872010-08-02 05:43:59 +00002774
Chandler Carruth0b1756b2012-01-26 01:35:15 +00002775 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
2776 // back to '/usr/lib' if it doesn't exist.
Chandler Carruthf7bf3db2012-01-25 11:24:24 +00002777 if ((Triple.getArch() == llvm::Triple::x86 ||
2778 Triple.getArch() == llvm::Triple::ppc) &&
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002779 D.getVFS().exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
Chandler Carruthf7bf3db2012-01-25 11:24:24 +00002780 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
2781 else
2782 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
Daniel Dunbare24297c2009-03-30 21:06:03 +00002783}
2784
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002785ToolChain::CXXStdlibType FreeBSD::GetCXXStdlibType(const ArgList &Args) const {
David Chisnall867ccd82013-11-09 15:10:56 +00002786 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2787 StringRef Value = A->getValue();
2788 if (Value == "libstdc++")
2789 return ToolChain::CST_Libstdcxx;
2790 if (Value == "libc++")
2791 return ToolChain::CST_Libcxx;
2792
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002793 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
David Chisnall867ccd82013-11-09 15:10:56 +00002794 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002795 if (getTriple().getOSMajorVersion() >= 10)
David Chisnall867ccd82013-11-09 15:10:56 +00002796 return ToolChain::CST_Libcxx;
2797 return ToolChain::CST_Libstdcxx;
2798}
2799
2800void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2801 ArgStringList &CC1Args) const {
2802 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2803 DriverArgs.hasArg(options::OPT_nostdincxx))
2804 return;
2805
2806 switch (GetCXXStdlibType(DriverArgs)) {
2807 case ToolChain::CST_Libcxx:
2808 addSystemInclude(DriverArgs, CC1Args,
2809 getDriver().SysRoot + "/usr/include/c++/v1");
2810 break;
2811 case ToolChain::CST_Libstdcxx:
2812 addSystemInclude(DriverArgs, CC1Args,
2813 getDriver().SysRoot + "/usr/include/c++/4.2");
2814 addSystemInclude(DriverArgs, CC1Args,
2815 getDriver().SysRoot + "/usr/include/c++/4.2/backward");
2816 break;
2817 }
2818}
2819
Rafael Espindola7cf32212013-03-20 03:05:54 +00002820Tool *FreeBSD::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002821 return new tools::freebsd::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002822}
2823
Douglas Katzman95354292015-06-23 20:42:09 +00002824Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); }
Daniel Dunbarcc912342009-05-02 18:28:39 +00002825
Rafael Espindola0f207ed2012-12-13 04:17:14 +00002826bool FreeBSD::UseSjLjExceptions() const {
2827 // FreeBSD uses SjLj exceptions on ARM oabi.
2828 switch (getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00002829 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00002830 case llvm::Triple::GNUEABI:
2831 case llvm::Triple::EABI:
2832 return false;
2833
2834 default:
2835 return (getTriple().getArch() == llvm::Triple::arm ||
2836 getTriple().getArch() == llvm::Triple::thumb);
2837 }
2838}
2839
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002840bool FreeBSD::HasNativeLLVMSupport() const { return true; }
Alexey Samsonove65ceb92014-02-25 13:26:03 +00002841
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002842bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
Alexey Samsonove65ceb92014-02-25 13:26:03 +00002843
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00002844SanitizerMask FreeBSD::getSupportedSanitizers() const {
2845 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
2846 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
2847 const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
2848 getTriple().getArch() == llvm::Triple::mips64el;
2849 SanitizerMask Res = ToolChain::getSupportedSanitizers();
2850 Res |= SanitizerKind::Address;
2851 Res |= SanitizerKind::Vptr;
2852 if (IsX86_64 || IsMIPS64) {
2853 Res |= SanitizerKind::Leak;
2854 Res |= SanitizerKind::Thread;
2855 }
2856 if (IsX86 || IsX86_64) {
2857 Res |= SanitizerKind::SafeStack;
2858 }
2859 return Res;
2860}
2861
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00002862/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
2863
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002864NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2865 : Generic_ELF(D, Triple, Args) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00002866
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +00002867 if (getDriver().UseStdLib) {
Chandler Carruth1ccbed82012-01-25 11:18:20 +00002868 // When targeting a 32-bit platform, try the special directory used on
2869 // 64-bit hosts, and only fall back to the main library directory if that
2870 // doesn't work.
2871 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
2872 // what all logic is needed to emulate the '=' prefix here.
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002873 switch (Triple.getArch()) {
2874 case llvm::Triple::x86:
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +00002875 getFilePaths().push_back("=/usr/lib/i386");
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002876 break;
2877 case llvm::Triple::arm:
Joerg Sonnenberger3a6c28a2014-05-07 08:24:23 +00002878 case llvm::Triple::armeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002879 case llvm::Triple::thumb:
Joerg Sonnenberger3a6c28a2014-05-07 08:24:23 +00002880 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002881 switch (Triple.getEnvironment()) {
2882 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002883 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002884 getFilePaths().push_back("=/usr/lib/eabi");
2885 break;
Joerg Sonnenberger17a80e42014-08-09 19:01:52 +00002886 case llvm::Triple::EABIHF:
2887 case llvm::Triple::GNUEABIHF:
2888 getFilePaths().push_back("=/usr/lib/eabihf");
2889 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002890 default:
2891 getFilePaths().push_back("=/usr/lib/oabi");
2892 break;
2893 }
2894 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00002895 case llvm::Triple::mips64:
2896 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00002897 if (tools::mips::hasMipsAbiArg(Args, "o32"))
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00002898 getFilePaths().push_back("=/usr/lib/o32");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00002899 else if (tools::mips::hasMipsAbiArg(Args, "64"))
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00002900 getFilePaths().push_back("=/usr/lib/64");
2901 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00002902 case llvm::Triple::ppc:
2903 getFilePaths().push_back("=/usr/lib/powerpc");
2904 break;
Joerg Sonnenberger8280abe2014-04-16 20:44:17 +00002905 case llvm::Triple::sparc:
2906 getFilePaths().push_back("=/usr/lib/sparc");
2907 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00002908 default:
2909 break;
2910 }
Chandler Carruth1ccbed82012-01-25 11:18:20 +00002911
2912 getFilePaths().push_back("=/usr/lib");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00002913 }
2914}
2915
Rafael Espindola7cf32212013-03-20 03:05:54 +00002916Tool *NetBSD::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002917 return new tools::netbsd::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002918}
2919
Douglas Katzman95354292015-06-23 20:42:09 +00002920Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00002921
Douglas Katzman95354292015-06-23 20:42:09 +00002922ToolChain::CXXStdlibType NetBSD::GetCXXStdlibType(const ArgList &Args) const {
Joerg Sonnenberger428ef1e2013-04-30 01:21:43 +00002923 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2924 StringRef Value = A->getValue();
2925 if (Value == "libstdc++")
2926 return ToolChain::CST_Libstdcxx;
2927 if (Value == "libc++")
2928 return ToolChain::CST_Libcxx;
2929
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002930 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
Joerg Sonnenberger428ef1e2013-04-30 01:21:43 +00002931 }
2932
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00002933 unsigned Major, Minor, Micro;
2934 getTriple().getOSVersion(Major, Minor, Micro);
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00002935 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00002936 switch (getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00002937 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00002938 case llvm::Triple::arm:
2939 case llvm::Triple::armeb:
2940 case llvm::Triple::thumb:
2941 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00002942 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00002943 case llvm::Triple::ppc64:
2944 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00002945 case llvm::Triple::x86:
2946 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00002947 return ToolChain::CST_Libcxx;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00002948 default:
2949 break;
2950 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00002951 }
Joerg Sonnenberger428ef1e2013-04-30 01:21:43 +00002952 return ToolChain::CST_Libstdcxx;
2953}
2954
2955void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2956 ArgStringList &CC1Args) const {
2957 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2958 DriverArgs.hasArg(options::OPT_nostdincxx))
2959 return;
2960
2961 switch (GetCXXStdlibType(DriverArgs)) {
2962 case ToolChain::CST_Libcxx:
2963 addSystemInclude(DriverArgs, CC1Args,
2964 getDriver().SysRoot + "/usr/include/c++/");
2965 break;
2966 case ToolChain::CST_Libstdcxx:
2967 addSystemInclude(DriverArgs, CC1Args,
2968 getDriver().SysRoot + "/usr/include/g++");
2969 addSystemInclude(DriverArgs, CC1Args,
2970 getDriver().SysRoot + "/usr/include/g++/backward");
2971 break;
2972 }
2973}
2974
Chris Lattner3e2ee142010-07-07 16:01:42 +00002975/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
2976
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002977Minix::Minix(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2978 : Generic_ELF(D, Triple, Args) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00002979 getFilePaths().push_back(getDriver().Dir + "/../lib");
2980 getFilePaths().push_back("/usr/lib");
Chris Lattner3e2ee142010-07-07 16:01:42 +00002981}
2982
Rafael Espindola7cf32212013-03-20 03:05:54 +00002983Tool *Minix::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00002984 return new tools::minix::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00002985}
2986
Douglas Katzman95354292015-06-23 20:42:09 +00002987Tool *Minix::buildLinker() const { return new tools::minix::Linker(*this); }
Chris Lattner3e2ee142010-07-07 16:01:42 +00002988
Benjamin Kramerd45b2052015-10-07 15:48:01 +00002989static void addPathIfExists(const Driver &D, const Twine &Path,
2990 ToolChain::path_list &Paths) {
2991 if (D.getVFS().exists(Path))
Rafael Espindolac53c5b12015-08-31 19:17:51 +00002992 Paths.push_back(Path.str());
2993}
2994
David Chisnallf571cde2012-02-15 13:39:01 +00002995/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
2996
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002997Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola1af7c212012-02-19 01:38:32 +00002998 const ArgList &Args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002999 : Generic_GCC(D, Triple, Args) {
David Chisnallf571cde2012-02-15 13:39:01 +00003000
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003001 GCCInstallation.init(Triple, Args);
David Chisnallf571cde2012-02-15 13:39:01 +00003002
Rafael Espindolac53c5b12015-08-31 19:17:51 +00003003 path_list &Paths = getFilePaths();
3004 if (GCCInstallation.isValid())
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003005 addPathIfExists(D, GCCInstallation.getInstallPath(), Paths);
Rafael Espindolac53c5b12015-08-31 19:17:51 +00003006
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003007 addPathIfExists(D, getDriver().getInstalledDir(), Paths);
Rafael Espindolac53c5b12015-08-31 19:17:51 +00003008 if (getDriver().getInstalledDir() != getDriver().Dir)
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003009 addPathIfExists(D, getDriver().Dir, Paths);
Rafael Espindolac53c5b12015-08-31 19:17:51 +00003010
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003011 addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);
Rafael Espindolac53c5b12015-08-31 19:17:51 +00003012
3013 std::string LibPath = "/usr/lib/";
3014 switch (Triple.getArch()) {
3015 case llvm::Triple::x86:
3016 case llvm::Triple::sparc:
3017 break;
3018 case llvm::Triple::x86_64:
3019 LibPath += "amd64/";
3020 break;
3021 case llvm::Triple::sparcv9:
3022 LibPath += "sparcv9/";
3023 break;
3024 default:
3025 llvm_unreachable("Unsupported architecture");
3026 }
3027
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003028 addPathIfExists(D, getDriver().SysRoot + LibPath, Paths);
David Chisnallf571cde2012-02-15 13:39:01 +00003029}
3030
Rafael Espindola7cf32212013-03-20 03:05:54 +00003031Tool *Solaris::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00003032 return new tools::solaris::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00003033}
3034
Douglas Katzman95354292015-06-23 20:42:09 +00003035Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00003036
Rafael Espindolad5117262015-09-09 13:36:00 +00003037void Solaris::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3038 ArgStringList &CC1Args) const {
3039 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3040 DriverArgs.hasArg(options::OPT_nostdincxx))
3041 return;
3042
3043 // Include the support directory for things like xlocale and fudged system
3044 // headers.
3045 addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/v1/support/solaris");
3046
3047 if (GCCInstallation.isValid()) {
3048 GCCVersion Version = GCCInstallation.getVersion();
3049 addSystemInclude(DriverArgs, CC1Args,
3050 getDriver().SysRoot + "/usr/gcc/" +
3051 Version.MajorStr + "." +
3052 Version.MinorStr +
3053 "/include/c++/" + Version.Text);
3054 addSystemInclude(DriverArgs, CC1Args,
3055 getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +
3056 "." + Version.MinorStr + "/include/c++/" +
3057 Version.Text + "/" +
3058 GCCInstallation.getTriple().str());
3059 }
3060}
3061
Thomas Schwinge6d94da02013-03-28 19:02:48 +00003062/// Distribution (very bare-bones at the moment).
Eli Friedman5cd659f2009-05-26 07:52:18 +00003063
Thomas Schwinge6d94da02013-03-28 19:02:48 +00003064enum Distro {
Douglas Katzmana5df0c82015-06-22 20:55:31 +00003065 // NB: Releases of a particular Linux distro should be kept together
3066 // in this enum, because some tests are done by integer comparison against
3067 // the first and last known member in the family, e.g. IsRedHat().
Chandler Carruth6a4e8e32011-02-25 06:39:53 +00003068 ArchLinux,
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003069 DebianLenny,
3070 DebianSqueeze,
Eli Friedmanf7600942011-06-02 21:36:53 +00003071 DebianWheezy,
Sylvestre Ledrubdef2892013-01-06 08:09:29 +00003072 DebianJessie,
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003073 DebianStretch,
Rafael Espindola12479842010-11-11 02:07:13 +00003074 Exherbo,
Chris Lattner84e38552011-05-22 05:36:06 +00003075 RHEL4,
3076 RHEL5,
3077 RHEL6,
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003078 RHEL7,
Rafael Espindola0d2cbc02013-10-25 18:09:41 +00003079 Fedora,
Rafael Espindola10a63c22013-07-03 14:14:00 +00003080 OpenSUSE,
Douglas Gregor0a36f4d2011-03-14 15:39:50 +00003081 UbuntuHardy,
3082 UbuntuIntrepid,
Rafael Espindola66b291a2010-11-10 05:00:22 +00003083 UbuntuJaunty,
Zhongxing Xu14776cf2010-11-15 09:01:52 +00003084 UbuntuKarmic,
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003085 UbuntuLucid,
3086 UbuntuMaverick,
Ted Kremenek43d47cc2011-04-05 22:04:27 +00003087 UbuntuNatty,
Benjamin Kramerf90b5de2011-06-05 16:08:59 +00003088 UbuntuOneiric,
Benjamin Kramer7c3f09d2012-02-06 14:36:09 +00003089 UbuntuPrecise,
Rafael Espindola62e87702012-12-13 20:26:05 +00003090 UbuntuQuantal,
3091 UbuntuRaring,
Sylvestre Ledru93c47b72013-06-13 11:52:27 +00003092 UbuntuSaucy,
Sylvestre Ledruaaf01a72013-11-07 09:31:30 +00003093 UbuntuTrusty,
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003094 UbuntuUtopic,
3095 UbuntuVivid,
Benjamin Kramer2d469802015-07-09 15:31:17 +00003096 UbuntuWily,
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003097 UnknownDistro
3098};
3099
Thomas Schwinge6d94da02013-03-28 19:02:48 +00003100static bool IsRedhat(enum Distro Distro) {
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003101 return Distro == Fedora || (Distro >= RHEL4 && Distro <= RHEL7);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003102}
3103
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003104static bool IsOpenSUSE(enum Distro Distro) { return Distro == OpenSUSE; }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003105
Thomas Schwinge6d94da02013-03-28 19:02:48 +00003106static bool IsDebian(enum Distro Distro) {
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003107 return Distro >= DebianLenny && Distro <= DebianStretch;
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003108}
3109
Thomas Schwinge6d94da02013-03-28 19:02:48 +00003110static bool IsUbuntu(enum Distro Distro) {
Benjamin Kramer2d469802015-07-09 15:31:17 +00003111 return Distro >= UbuntuHardy && Distro <= UbuntuWily;
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003112}
3113
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003114static Distro DetectDistro(const Driver &D, llvm::Triple::ArchType Arch) {
Rafael Espindola2d2b4202014-07-06 17:43:24 +00003115 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3116 llvm::MemoryBuffer::getFile("/etc/lsb-release");
3117 if (File) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003118 StringRef Data = File.get()->getBuffer();
Hans Wennborg3b7dd8d2014-08-11 18:09:32 +00003119 SmallVector<StringRef, 16> Lines;
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003120 Data.split(Lines, "\n");
Thomas Schwinge6d94da02013-03-28 19:02:48 +00003121 Distro Version = UnknownDistro;
Benjamin Kramer72e64312015-09-24 14:48:49 +00003122 for (StringRef Line : Lines)
Douglas Katzman6bbffc42015-06-25 18:51:37 +00003123 if (Version == UnknownDistro && Line.startswith("DISTRIB_CODENAME="))
3124 Version = llvm::StringSwitch<Distro>(Line.substr(17))
3125 .Case("hardy", UbuntuHardy)
3126 .Case("intrepid", UbuntuIntrepid)
3127 .Case("jaunty", UbuntuJaunty)
3128 .Case("karmic", UbuntuKarmic)
3129 .Case("lucid", UbuntuLucid)
3130 .Case("maverick", UbuntuMaverick)
3131 .Case("natty", UbuntuNatty)
3132 .Case("oneiric", UbuntuOneiric)
3133 .Case("precise", UbuntuPrecise)
3134 .Case("quantal", UbuntuQuantal)
3135 .Case("raring", UbuntuRaring)
3136 .Case("saucy", UbuntuSaucy)
3137 .Case("trusty", UbuntuTrusty)
3138 .Case("utopic", UbuntuUtopic)
3139 .Case("vivid", UbuntuVivid)
Benjamin Kramer2d469802015-07-09 15:31:17 +00003140 .Case("wily", UbuntuWily)
Douglas Katzman6bbffc42015-06-25 18:51:37 +00003141 .Default(UnknownDistro);
Benjamin Kramer7c3f09d2012-02-06 14:36:09 +00003142 return Version;
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003143 }
3144
Rafael Espindola2d2b4202014-07-06 17:43:24 +00003145 File = llvm::MemoryBuffer::getFile("/etc/redhat-release");
3146 if (File) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003147 StringRef Data = File.get()->getBuffer();
Rafael Espindola0d2cbc02013-10-25 18:09:41 +00003148 if (Data.startswith("Fedora release"))
3149 return Fedora;
Benjamin Kramer6af073b2014-05-05 12:39:32 +00003150 if (Data.startswith("Red Hat Enterprise Linux") ||
3151 Data.startswith("CentOS")) {
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003152 if (Data.find("release 7") != StringRef::npos)
3153 return RHEL7;
3154 else if (Data.find("release 6") != StringRef::npos)
Benjamin Kramer6af073b2014-05-05 12:39:32 +00003155 return RHEL6;
3156 else if (Data.find("release 5") != StringRef::npos)
3157 return RHEL5;
3158 else if (Data.find("release 4") != StringRef::npos)
3159 return RHEL4;
3160 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003161 return UnknownDistro;
3162 }
3163
Rafael Espindola2d2b4202014-07-06 17:43:24 +00003164 File = llvm::MemoryBuffer::getFile("/etc/debian_version");
3165 if (File) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003166 StringRef Data = File.get()->getBuffer();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003167 if (Data[0] == '5')
3168 return DebianLenny;
Rafael Espindola1510c852011-12-28 18:17:14 +00003169 else if (Data.startswith("squeeze/sid") || Data[0] == '6')
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003170 return DebianSqueeze;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003171 else if (Data.startswith("wheezy/sid") || Data[0] == '7')
Eli Friedmanf7600942011-06-02 21:36:53 +00003172 return DebianWheezy;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003173 else if (Data.startswith("jessie/sid") || Data[0] == '8')
Sylvestre Ledrubdef2892013-01-06 08:09:29 +00003174 return DebianJessie;
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003175 else if (Data.startswith("stretch/sid") || Data[0] == '9')
3176 return DebianStretch;
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003177 return UnknownDistro;
3178 }
3179
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003180 if (D.getVFS().exists("/etc/SuSE-release"))
Rafael Espindola10a63c22013-07-03 14:14:00 +00003181 return OpenSUSE;
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003182
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003183 if (D.getVFS().exists("/etc/exherbo-release"))
Rafael Espindola12479842010-11-11 02:07:13 +00003184 return Exherbo;
3185
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003186 if (D.getVFS().exists("/etc/arch-release"))
Chandler Carruth6a4e8e32011-02-25 06:39:53 +00003187 return ArchLinux;
3188
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003189 return UnknownDistro;
3190}
3191
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003192/// \brief Get our best guess at the multiarch triple for a target.
3193///
3194/// Debian-based systems are starting to use a multiarch setup where they use
3195/// a target-triple directory in the library and header search paths.
3196/// Unfortunately, this triple does not align with the vanilla target triple,
3197/// so we provide a rough mapping here.
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003198static std::string getMultiarchTriple(const Driver &D,
3199 const llvm::Triple &TargetTriple,
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003200 StringRef SysRoot) {
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003201 llvm::Triple::EnvironmentType TargetEnvironment = TargetTriple.getEnvironment();
3202
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003203 // For most architectures, just use whatever we have rather than trying to be
3204 // clever.
3205 switch (TargetTriple.getArch()) {
3206 default:
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003207 break;
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003208
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003209 // We use the existence of '/lib/<triple>' as a directory to detect some
3210 // common linux triples that don't quite match the Clang triple for both
3211 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
3212 // regardless of what the actual target triple is.
Chad Rosier4dce73a2012-07-11 19:08:21 +00003213 case llvm::Triple::arm:
3214 case llvm::Triple::thumb:
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003215 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003216 if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabihf"))
Jiangning Liu61b06cb2012-07-31 08:06:29 +00003217 return "arm-linux-gnueabihf";
3218 } else {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003219 if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabi"))
Jiangning Liu61b06cb2012-07-31 08:06:29 +00003220 return "arm-linux-gnueabi";
3221 }
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003222 break;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003223 case llvm::Triple::armeb:
3224 case llvm::Triple::thumbeb:
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003225 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003226 if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabihf"))
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003227 return "armeb-linux-gnueabihf";
3228 } else {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003229 if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabi"))
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003230 return "armeb-linux-gnueabi";
3231 }
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003232 break;
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003233 case llvm::Triple::x86:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003234 if (D.getVFS().exists(SysRoot + "/lib/i386-linux-gnu"))
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003235 return "i386-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003236 break;
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003237 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00003238 // We don't want this for x32, otherwise it will match x86_64 libs
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003239 if (TargetEnvironment != llvm::Triple::GNUX32 &&
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003240 D.getVFS().exists(SysRoot + "/lib/x86_64-linux-gnu"))
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003241 return "x86_64-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003242 break;
Tim Northover9bb857a2013-01-31 12:13:10 +00003243 case llvm::Triple::aarch64:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003244 if (D.getVFS().exists(SysRoot + "/lib/aarch64-linux-gnu"))
Tim Northover9bb857a2013-01-31 12:13:10 +00003245 return "aarch64-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003246 break;
Christian Pirkera74c7912014-03-14 12:15:45 +00003247 case llvm::Triple::aarch64_be:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003248 if (D.getVFS().exists(SysRoot + "/lib/aarch64_be-linux-gnu"))
Christian Pirkera74c7912014-03-14 12:15:45 +00003249 return "aarch64_be-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003250 break;
Eli Friedman27b8c4f2011-11-08 19:43:37 +00003251 case llvm::Triple::mips:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003252 if (D.getVFS().exists(SysRoot + "/lib/mips-linux-gnu"))
Eli Friedman27b8c4f2011-11-08 19:43:37 +00003253 return "mips-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003254 break;
Eli Friedman27b8c4f2011-11-08 19:43:37 +00003255 case llvm::Triple::mipsel:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003256 if (D.getVFS().exists(SysRoot + "/lib/mipsel-linux-gnu"))
Eli Friedman27b8c4f2011-11-08 19:43:37 +00003257 return "mipsel-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003258 break;
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003259 case llvm::Triple::mips64:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003260 if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003261 return "mips64-linux-gnu";
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003262 if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnuabi64"))
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003263 return "mips64-linux-gnuabi64";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003264 break;
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003265 case llvm::Triple::mips64el:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003266 if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003267 return "mips64el-linux-gnu";
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003268 if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnuabi64"))
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003269 return "mips64el-linux-gnuabi64";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003270 break;
Chandler Carruthaf3c2092012-02-26 09:03:21 +00003271 case llvm::Triple::ppc:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003272 if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
Sylvestre Ledrue0bf5812013-03-15 16:22:43 +00003273 return "powerpc-linux-gnuspe";
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003274 if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnu"))
Chandler Carruthaf3c2092012-02-26 09:03:21 +00003275 return "powerpc-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003276 break;
Chandler Carruthaf3c2092012-02-26 09:03:21 +00003277 case llvm::Triple::ppc64:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003278 if (D.getVFS().exists(SysRoot + "/lib/powerpc64-linux-gnu"))
Chandler Carruthaf3c2092012-02-26 09:03:21 +00003279 return "powerpc64-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003280 break;
Bill Schmidt778d3872013-07-26 01:36:11 +00003281 case llvm::Triple::ppc64le:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003282 if (D.getVFS().exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
Bill Schmidt778d3872013-07-26 01:36:11 +00003283 return "powerpc64le-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003284 break;
James Y Knightc0aeadf2015-06-04 15:36:30 +00003285 case llvm::Triple::sparc:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003286 if (D.getVFS().exists(SysRoot + "/lib/sparc-linux-gnu"))
James Y Knightc0aeadf2015-06-04 15:36:30 +00003287 return "sparc-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003288 break;
James Y Knightc0aeadf2015-06-04 15:36:30 +00003289 case llvm::Triple::sparcv9:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003290 if (D.getVFS().exists(SysRoot + "/lib/sparc64-linux-gnu"))
James Y Knightc0aeadf2015-06-04 15:36:30 +00003291 return "sparc64-linux-gnu";
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003292 break;
Sylvestre Ledruc0babf22015-08-28 12:26:09 +00003293 case llvm::Triple::systemz:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003294 if (D.getVFS().exists(SysRoot + "/lib/s390x-linux-gnu"))
Sylvestre Ledruc0babf22015-08-28 12:26:09 +00003295 return "s390x-linux-gnu";
3296 break;
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003297 }
Douglas Katzmanecddb3a2015-06-26 18:37:15 +00003298 return TargetTriple.str();
Chandler Carruthfb7fa242011-10-31 08:42:24 +00003299}
3300
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003301static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
Chandler Carruthda797042013-10-29 10:27:30 +00003302 if (isMipsArch(Triple.getArch())) {
3303 // lib32 directory has a special meaning on MIPS targets.
3304 // It contains N32 ABI binaries. Use this folder if produce
3305 // code for N32 ABI only.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003306 if (tools::mips::hasMipsAbiArg(Args, "n32"))
Chandler Carruthda797042013-10-29 10:27:30 +00003307 return "lib32";
3308 return Triple.isArch32Bit() ? "lib" : "lib64";
3309 }
Simon Atanasyand4413882012-09-14 11:27:24 +00003310
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003311 // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and
Chandler Carruthda797042013-10-29 10:27:30 +00003312 // using that variant while targeting other architectures causes problems
3313 // because the libraries are laid out in shared system roots that can't cope
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003314 // with a 'lib32' library search path being considered. So we only enable
Chandler Carruthda797042013-10-29 10:27:30 +00003315 // them when we know we may need it.
3316 //
3317 // FIXME: This is a bit of a hack. We should really unify this code for
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003318 // reasoning about oslibdir spellings with the lib dir spellings in the
Chandler Carruthda797042013-10-29 10:27:30 +00003319 // GCCInstallationDetector, but that is a more significant refactoring.
3320 if (Triple.getArch() == llvm::Triple::x86 ||
3321 Triple.getArch() == llvm::Triple::ppc)
Simon Atanasyand4413882012-09-14 11:27:24 +00003322 return "lib32";
3323
Zinovy Nis1db95732014-07-10 15:27:19 +00003324 if (Triple.getArch() == llvm::Triple::x86_64 &&
3325 Triple.getEnvironment() == llvm::Triple::GNUX32)
3326 return "libx32";
3327
Simon Atanasyand4413882012-09-14 11:27:24 +00003328 return Triple.isArch32Bit() ? "lib" : "lib64";
3329}
3330
Rafael Espindola1af7c212012-02-19 01:38:32 +00003331Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003332 : Generic_ELF(D, Triple, Args) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003333 GCCInstallation.init(Triple, Args);
3334 CudaInstallation.init(Triple, Args);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003335 Multilibs = GCCInstallation.getMultilibs();
Chandler Carruth96bae7b2012-01-24 20:08:17 +00003336 llvm::Triple::ArchType Arch = Triple.getArch();
Simon Atanasyana0d89572013-10-05 14:37:55 +00003337 std::string SysRoot = computeSysRoot();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003338
Rafael Espindola10a63c22013-07-03 14:14:00 +00003339 // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
Chandler Carruthd6c62b62013-06-20 23:37:54 +00003340 // least) put various tools in a triple-prefixed directory off of the parent
3341 // of the GCC installation. We use the GCC triple here to ensure that we end
3342 // up with tools that support the same amount of cross compiling as the
3343 // detected GCC installation. For example, if we find a GCC installation
3344 // targeting x86_64, but it is a bi-arch GCC installation, it can also be
3345 // used to target i386.
3346 // FIXME: This seems unlikely to be Linux-specific.
Rafael Espindola5f344ff2011-09-01 16:25:49 +00003347 ToolChain::path_list &PPaths = getProgramPaths();
Chandler Carruth4be70dd2011-11-06 09:21:54 +00003348 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003349 GCCInstallation.getTriple().str() + "/bin")
3350 .str());
Rafael Espindola5f344ff2011-09-01 16:25:49 +00003351
Logan Chieneb9162f2014-06-26 14:23:45 +00003352 Linker = GetLinkerPath();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003353
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003354 Distro Distro = DetectDistro(D, Arch);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003355
Rafael Espindola10a63c22013-07-03 14:14:00 +00003356 if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
Rafael Espindolac5688622010-11-08 14:48:47 +00003357 ExtraOpts.push_back("-z");
3358 ExtraOpts.push_back("relro");
3359 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003360
Douglas Gregord9bb1522011-03-06 19:11:49 +00003361 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003362 ExtraOpts.push_back("-X");
3363
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00003364 const bool IsAndroid = Triple.isAndroid();
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003365 const bool IsMips = isMipsArch(Arch);
3366
3367 if (IsMips && !SysRoot.empty())
3368 ExtraOpts.push_back("--sysroot=" + SysRoot);
Evgeniy Stepanov2ca1aa52012-01-13 09:30:38 +00003369
Chandler Carruth0b842912011-12-09 04:45:18 +00003370 // Do not use 'gnu' hash style for Mips targets because .gnu.hash
3371 // and the MIPS ABI require .dynsym to be sorted in different ways.
3372 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
3373 // ABI requires a mapping between the GOT and the symbol table.
Evgeniy Stepanov2ca1aa52012-01-13 09:30:38 +00003374 // Android loader does not support .gnu.hash.
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003375 if (!IsMips && !IsAndroid) {
Rafael Espindola10a63c22013-07-03 14:14:00 +00003376 if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
Benjamin Kramer7c3f09d2012-02-06 14:36:09 +00003377 (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
Chandler Carruth0b842912011-12-09 04:45:18 +00003378 ExtraOpts.push_back("--hash-style=gnu");
3379
Rafael Espindola10a63c22013-07-03 14:14:00 +00003380 if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
Chandler Carruth0b842912011-12-09 04:45:18 +00003381 Distro == UbuntuJaunty || Distro == UbuntuKarmic)
3382 ExtraOpts.push_back("--hash-style=both");
3383 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003384
Chris Lattner84e38552011-05-22 05:36:06 +00003385 if (IsRedhat(Distro))
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003386 ExtraOpts.push_back("--no-add-needed");
3387
Benjamin Kramer1a8fa8b2015-04-06 12:30:43 +00003388 if ((IsDebian(Distro) && Distro >= DebianSqueeze) || IsOpenSUSE(Distro) ||
Rafael Espindolad8f92c82011-06-03 15:23:24 +00003389 (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
Benjamin Kramer7c3f09d2012-02-06 14:36:09 +00003390 (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003391 ExtraOpts.push_back("--build-id");
3392
Rafael Espindola10a63c22013-07-03 14:14:00 +00003393 if (IsOpenSUSE(Distro))
Chandler Carruthe5d9d902011-05-24 07:51:17 +00003394 ExtraOpts.push_back("--enable-new-dtags");
Chris Lattnerd075c822011-05-22 16:45:07 +00003395
Chandler Carruth413e5ac2011-10-03 05:28:29 +00003396 // The selection of paths to try here is designed to match the patterns which
3397 // the GCC driver itself uses, as this is part of the GCC-compatible driver.
3398 // This was determined by running GCC in a fake filesystem, creating all
3399 // possible permutations of these directories, and seeing which ones it added
3400 // to the link paths.
3401 path_list &Paths = getFilePaths();
Chandler Carruth6a4e8e32011-02-25 06:39:53 +00003402
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003403 const std::string OSLibDir = getOSLibDir(Triple, Args);
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003404 const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
Chandler Carruth413e5ac2011-10-03 05:28:29 +00003405
Chandler Carruthd0b93d62011-11-06 23:09:05 +00003406 // Add the multilib suffixed paths where they are available.
3407 if (GCCInstallation.isValid()) {
Chandler Carruth4d9d7682012-01-24 19:28:29 +00003408 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
Chandler Carruth96bae7b2012-01-24 20:08:17 +00003409 const std::string &LibPath = GCCInstallation.getParentLibPath();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003410 const Multilib &Multilib = GCCInstallation.getMultilib();
Simon Atanasyan53fefd12012-10-03 17:46:38 +00003411
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003412 // Sourcery CodeBench MIPS toolchain holds some libraries under
Chandler Carruth9b6ce932013-10-29 02:27:56 +00003413 // a biarch-like suffix of the GCC installation.
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003414 addPathIfExists(D, GCCInstallation.getInstallPath() + Multilib.gccSuffix(),
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003415 Paths);
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003416
3417 // GCC cross compiling toolchains will install target libraries which ship
3418 // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
3419 // any part of the GCC installation in
3420 // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
3421 // debatable, but is the reality today. We need to search this tree even
3422 // when we have a sysroot somewhere else. It is the responsibility of
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003423 // whomever is doing the cross build targeting a sysroot using a GCC
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003424 // installation that is *not* within the system root to ensure two things:
3425 //
3426 // 1) Any DSOs that are linked in from this tree or from the install path
Alexander Potapenkoc8e749a2014-09-01 12:35:57 +00003427 // above must be present on the system root and found via an
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003428 // appropriate rpath.
3429 // 2) There must not be libraries installed into
3430 // <prefix>/<triple>/<libdir> unless they should be preferred over
3431 // those within the system root.
3432 //
3433 // Note that this matches the GCC behavior. See the below comment for where
3434 // Clang diverges from GCC's behavior.
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003435 addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
3436 OSLibDir + Multilib.osSuffix(),
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003437 Paths);
3438
Chandler Carruth69a125b2012-04-06 16:32:06 +00003439 // If the GCC installation we found is inside of the sysroot, we want to
3440 // prefer libraries installed in the parent prefix of the GCC installation.
3441 // It is important to *not* use these paths when the GCC installation is
Gabor Greif5d3231c2012-04-18 10:59:08 +00003442 // outside of the system root as that can pick up unintended libraries.
Chandler Carruth69a125b2012-04-06 16:32:06 +00003443 // This usually happens when there is an external cross compiler on the
3444 // host system, and a more minimal sysroot available that is the target of
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003445 // the cross. Note that GCC does include some of these directories in some
3446 // configurations but this seems somewhere between questionable and simply
3447 // a bug.
Chandler Carruth69a125b2012-04-06 16:32:06 +00003448 if (StringRef(LibPath).startswith(SysRoot)) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003449 addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);
3450 addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
Chandler Carruth69a125b2012-04-06 16:32:06 +00003451 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003452 }
Chandler Carruth902efc62014-01-21 22:49:05 +00003453
3454 // Similar to the logic for GCC above, if we currently running Clang inside
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003455 // of the requested system root, add its parent library paths to
Chandler Carruth902efc62014-01-21 22:49:05 +00003456 // those searched.
3457 // FIXME: It's not clear whether we should use the driver's installed
3458 // directory ('Dir' below) or the ResourceDir.
3459 if (StringRef(D.Dir).startswith(SysRoot)) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003460 addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);
3461 addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
Chandler Carruth902efc62014-01-21 22:49:05 +00003462 }
3463
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003464 addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
3465 addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
3466 addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
3467 addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
Chandler Carruthd0b93d62011-11-06 23:09:05 +00003468
Chandler Carruthb427c562013-06-22 11:35:51 +00003469 // Try walking via the GCC triple path in case of biarch or multiarch GCC
Chandler Carruthd0b93d62011-11-06 23:09:05 +00003470 // installations with strange symlinks.
Rafael Espindolab6250162013-10-25 17:06:04 +00003471 if (GCCInstallation.isValid()) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003472 addPathIfExists(D,
3473 SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003474 "/../../" + OSLibDir,
3475 Paths);
Rafael Espindola30490212011-06-03 15:39:42 +00003476
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003477 // Add the 'other' biarch variant path
3478 Multilib BiarchSibling;
3479 if (GCCInstallation.getBiarchSibling(BiarchSibling)) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003480 addPathIfExists(D, GCCInstallation.getInstallPath() +
3481 BiarchSibling.gccSuffix(),
3482 Paths);
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003483 }
Chandler Carruth69a125b2012-04-06 16:32:06 +00003484
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003485 // See comments above on the multilib variant for details of why this is
3486 // included even from outside the sysroot.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003487 const std::string &LibPath = GCCInstallation.getParentLibPath();
3488 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
3489 const Multilib &Multilib = GCCInstallation.getMultilib();
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003490 addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +
3491 Multilib.osSuffix(),
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003492 Paths);
Chandler Carruth7f8042c2013-07-31 00:37:07 +00003493
3494 // See comments above on the multilib variant for details of why this is
3495 // only included from within the sysroot.
3496 if (StringRef(LibPath).startswith(SysRoot))
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003497 addPathIfExists(D, LibPath, Paths);
Chandler Carruth413e5ac2011-10-03 05:28:29 +00003498 }
Chandler Carruth902efc62014-01-21 22:49:05 +00003499
3500 // Similar to the logic for GCC above, if we are currently running Clang
3501 // inside of the requested system root, add its parent library path to those
3502 // searched.
3503 // FIXME: It's not clear whether we should use the driver's installed
3504 // directory ('Dir' below) or the ResourceDir.
3505 if (StringRef(D.Dir).startswith(SysRoot))
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003506 addPathIfExists(D, D.Dir + "/../lib", Paths);
Chandler Carruth902efc62014-01-21 22:49:05 +00003507
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003508 addPathIfExists(D, SysRoot + "/lib", Paths);
3509 addPathIfExists(D, SysRoot + "/usr/lib", Paths);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00003510}
3511
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003512bool Linux::HasNativeLLVMSupport() const { return true; }
Eli Friedman5cd659f2009-05-26 07:52:18 +00003513
Douglas Katzman95354292015-06-23 20:42:09 +00003514Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
Rafael Espindola7cf32212013-03-20 03:05:54 +00003515
3516Tool *Linux::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00003517 return new tools::gnutools::Assembler(*this);
Rafael Espindola92b00932010-08-10 00:25:48 +00003518}
3519
Simon Atanasyana0d89572013-10-05 14:37:55 +00003520std::string Linux::computeSysRoot() const {
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003521 if (!getDriver().SysRoot.empty())
3522 return getDriver().SysRoot;
3523
3524 if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
3525 return std::string();
3526
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003527 // Standalone MIPS toolchains use different names for sysroot folder
3528 // and put it into different places. Here we try to check some known
3529 // variants.
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003530
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003531 const StringRef InstallDir = GCCInstallation.getInstallPath();
3532 const StringRef TripleStr = GCCInstallation.getTriple().str();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003533 const Multilib &Multilib = GCCInstallation.getMultilib();
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003534
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003535 std::string Path =
3536 (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
3537 .str();
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003538
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003539 if (getVFS().exists(Path))
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003540 return Path;
3541
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003542 Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003543
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003544 if (getVFS().exists(Path))
Simon Atanasyana61b7ec2013-10-10 07:57:44 +00003545 return Path;
3546
3547 return std::string();
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003548}
3549
Chandler Carrutha796f532011-11-05 20:17:13 +00003550void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
3551 ArgStringList &CC1Args) const {
3552 const Driver &D = getDriver();
Simon Atanasyana0d89572013-10-05 14:37:55 +00003553 std::string SysRoot = computeSysRoot();
Chandler Carrutha796f532011-11-05 20:17:13 +00003554
3555 if (DriverArgs.hasArg(options::OPT_nostdinc))
3556 return;
3557
3558 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003559 addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
Chandler Carrutha796f532011-11-05 20:17:13 +00003560
3561 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
Rafael Espindola358256c2013-06-26 02:13:00 +00003562 SmallString<128> P(D.ResourceDir);
3563 llvm::sys::path::append(P, "include");
Yaron Keren92e1b622015-03-18 10:17:07 +00003564 addSystemInclude(DriverArgs, CC1Args, P);
Chandler Carrutha796f532011-11-05 20:17:13 +00003565 }
3566
3567 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3568 return;
3569
3570 // Check for configure-time C include directories.
3571 StringRef CIncludeDirs(C_INCLUDE_DIRS);
3572 if (CIncludeDirs != "") {
3573 SmallVector<StringRef, 5> dirs;
3574 CIncludeDirs.split(dirs, ":");
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003575 for (StringRef dir : dirs) {
Benjamin Kramer33cd6dc2015-02-18 18:45:54 +00003576 StringRef Prefix =
3577 llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : "";
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003578 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
Chandler Carrutha796f532011-11-05 20:17:13 +00003579 }
3580 return;
3581 }
3582
3583 // Lacking those, try to detect the correct set of system includes for the
3584 // target triple.
3585
Simon Atanasyan9e49e142014-08-06 05:44:47 +00003586 // Add include directories specific to the selected multilib set and multilib.
3587 if (GCCInstallation.isValid()) {
Benjamin Kramerac75baa2015-03-22 15:56:12 +00003588 const auto &Callback = Multilibs.includeDirsCallback();
Simon Atanasyan9e49e142014-08-06 05:44:47 +00003589 if (Callback) {
3590 const auto IncludePaths = Callback(GCCInstallation.getInstallPath(),
3591 GCCInstallation.getTriple().str(),
3592 GCCInstallation.getMultilib());
3593 for (const auto &Path : IncludePaths)
3594 addExternCSystemIncludeIfExists(DriverArgs, CC1Args, Path);
3595 }
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003596 }
3597
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003598 // Implement generic Debian multiarch support.
3599 const StringRef X86_64MultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003600 "/usr/include/x86_64-linux-gnu",
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003601
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003602 // FIXME: These are older forms of multiarch. It's not clear that they're
3603 // in use in any released version of Debian, so we should consider
3604 // removing them.
3605 "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"};
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003606 const StringRef X86MultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003607 "/usr/include/i386-linux-gnu",
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003608
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003609 // FIXME: These are older forms of multiarch. It's not clear that they're
3610 // in use in any released version of Debian, so we should consider
3611 // removing them.
3612 "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
3613 "/usr/include/i486-linux-gnu"};
Tim Northover9bb857a2013-01-31 12:13:10 +00003614 const StringRef AArch64MultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003615 "/usr/include/aarch64-linux-gnu"};
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003616 const StringRef ARMMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003617 "/usr/include/arm-linux-gnueabi"};
Jiangning Liu61b06cb2012-07-31 08:06:29 +00003618 const StringRef ARMHFMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003619 "/usr/include/arm-linux-gnueabihf"};
3620 const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"};
Eli Friedman7771c832011-11-11 03:05:19 +00003621 const StringRef MIPSELMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003622 "/usr/include/mipsel-linux-gnu"};
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003623 const StringRef MIPS64MultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003624 "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"};
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003625 const StringRef MIPS64ELMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003626 "/usr/include/mips64el-linux-gnu",
3627 "/usr/include/mips64el-linux-gnuabi64"};
Chandler Carruth2e9d7312012-02-26 09:21:43 +00003628 const StringRef PPCMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003629 "/usr/include/powerpc-linux-gnu"};
Chandler Carruth2e9d7312012-02-26 09:21:43 +00003630 const StringRef PPC64MultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003631 "/usr/include/powerpc64-linux-gnu"};
Ulrich Weiganda8331b92014-06-20 13:41:24 +00003632 const StringRef PPC64LEMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003633 "/usr/include/powerpc64le-linux-gnu"};
James Y Knight09677ad2015-06-05 13:44:43 +00003634 const StringRef SparcMultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003635 "/usr/include/sparc-linux-gnu"};
James Y Knight09677ad2015-06-05 13:44:43 +00003636 const StringRef Sparc64MultiarchIncludeDirs[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003637 "/usr/include/sparc64-linux-gnu"};
Sylvestre Ledruc0babf22015-08-28 12:26:09 +00003638 const StringRef SYSTEMZMultiarchIncludeDirs[] = {
3639 "/usr/include/s390x-linux-gnu"};
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003640 ArrayRef<StringRef> MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003641 switch (getTriple().getArch()) {
3642 case llvm::Triple::x86_64:
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003643 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003644 break;
3645 case llvm::Triple::x86:
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003646 MultiarchIncludeDirs = X86MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003647 break;
3648 case llvm::Triple::aarch64:
3649 case llvm::Triple::aarch64_be:
Tim Northover9bb857a2013-01-31 12:13:10 +00003650 MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003651 break;
3652 case llvm::Triple::arm:
Jiangning Liu61b06cb2012-07-31 08:06:29 +00003653 if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
3654 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
3655 else
3656 MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003657 break;
3658 case llvm::Triple::mips:
Eli Friedman7771c832011-11-11 03:05:19 +00003659 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003660 break;
3661 case llvm::Triple::mipsel:
Eli Friedman7771c832011-11-11 03:05:19 +00003662 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003663 break;
3664 case llvm::Triple::mips64:
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003665 MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003666 break;
3667 case llvm::Triple::mips64el:
Simon Atanasyan3a46afa2014-06-24 19:00:12 +00003668 MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003669 break;
3670 case llvm::Triple::ppc:
Chandler Carruth2e9d7312012-02-26 09:21:43 +00003671 MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003672 break;
3673 case llvm::Triple::ppc64:
Chandler Carruth2e9d7312012-02-26 09:21:43 +00003674 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003675 break;
3676 case llvm::Triple::ppc64le:
Ulrich Weiganda8331b92014-06-20 13:41:24 +00003677 MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003678 break;
3679 case llvm::Triple::sparc:
James Y Knight09677ad2015-06-05 13:44:43 +00003680 MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003681 break;
3682 case llvm::Triple::sparcv9:
James Y Knight09677ad2015-06-05 13:44:43 +00003683 MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003684 break;
Sylvestre Ledruc0babf22015-08-28 12:26:09 +00003685 case llvm::Triple::systemz:
3686 MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;
3687 break;
Douglas Katzman7e37afb2015-06-23 03:02:39 +00003688 default:
3689 break;
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003690 }
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003691 for (StringRef Dir : MultiarchIncludeDirs) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003692 if (D.getVFS().exists(SysRoot + Dir)) {
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003693 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);
Chandler Carruth5b77c6c2011-11-06 08:21:07 +00003694 break;
3695 }
Chandler Carrutha796f532011-11-05 20:17:13 +00003696 }
3697
3698 if (getTriple().getOS() == llvm::Triple::RTEMS)
3699 return;
3700
Chandler Carruth475ab6a2011-11-08 17:19:47 +00003701 // Add an include of '/include' directly. This isn't provided by default by
3702 // system GCCs, but is often used with cross-compiling GCCs, and harmless to
3703 // add even when Clang is acting as-if it were a system compiler.
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003704 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
Chandler Carruth475ab6a2011-11-08 17:19:47 +00003705
Simon Atanasyan08450bd2013-04-20 08:15:03 +00003706 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
Chandler Carrutha796f532011-11-05 20:17:13 +00003707}
3708
Dmitri Gribenko15225ae2013-03-06 17:14:05 +00003709
Chandler Carrutha796f532011-11-05 20:17:13 +00003710void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3711 ArgStringList &CC1Args) const {
3712 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3713 DriverArgs.hasArg(options::OPT_nostdincxx))
3714 return;
3715
Chandler Carruthf4701732011-11-07 09:01:17 +00003716 // Check if libc++ has been enabled and provide its include paths if so.
3717 if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
Chandler Carruth5a3d8982014-01-20 09:42:24 +00003718 const std::string LibCXXIncludePathCandidates[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003719 // The primary location is within the Clang installation.
3720 // FIXME: We shouldn't hard code 'v1' here to make Clang future proof to
3721 // newer ABI versions.
3722 getDriver().Dir + "/../include/c++/v1",
Chandler Carruth5a3d8982014-01-20 09:42:24 +00003723
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003724 // We also check the system as for a long time this is the only place
3725 // Clang looked.
3726 // FIXME: We should really remove this. It doesn't make any sense.
3727 getDriver().SysRoot + "/usr/include/c++/v1"};
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003728 for (const auto &IncludePath : LibCXXIncludePathCandidates) {
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003729 if (!getVFS().exists(IncludePath))
Chandler Carruth5a3d8982014-01-20 09:42:24 +00003730 continue;
3731 // Add the first candidate that exists.
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003732 addSystemInclude(DriverArgs, CC1Args, IncludePath);
Chandler Carruth5a3d8982014-01-20 09:42:24 +00003733 break;
3734 }
Chandler Carruthf4701732011-11-07 09:01:17 +00003735 return;
3736 }
3737
Chandler Carrutha1f1fd32012-01-25 08:04:13 +00003738 // We need a detected GCC installation on Linux to provide libstdc++'s
3739 // headers. We handled the libc++ case above.
3740 if (!GCCInstallation.isValid())
3741 return;
Chandler Carrutha796f532011-11-05 20:17:13 +00003742
Chandler Carruthf5d4df92011-11-06 10:31:01 +00003743 // By default, look for the C++ headers in an include directory adjacent to
3744 // the lib directory of the GCC installation. Note that this is expect to be
3745 // equivalent to '/usr/include/c++/X.Y' in almost all cases.
3746 StringRef LibDir = GCCInstallation.getParentLibPath();
3747 StringRef InstallDir = GCCInstallation.getInstallPath();
Evgeniy Stepanov763671e2012-09-03 09:05:50 +00003748 StringRef TripleStr = GCCInstallation.getTriple().str();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003749 const Multilib &Multilib = GCCInstallation.getMultilib();
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003750 const std::string GCCMultiarchTriple = getMultiarchTriple(
3751 getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot);
Chandler Carruthc44f4d42014-08-27 08:41:41 +00003752 const std::string TargetMultiarchTriple =
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003753 getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot);
Chandler Carruth1f2b2f82013-08-26 08:59:53 +00003754 const GCCVersion &Version = GCCInstallation.getVersion();
Evgeniy Stepanov763671e2012-09-03 09:05:50 +00003755
Chandler Carruthc44f4d42014-08-27 08:41:41 +00003756 // The primary search for libstdc++ supports multiarch variants.
Chandler Carruth8677d922013-10-29 08:53:03 +00003757 if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003758 "/c++/" + Version.Text, TripleStr,
3759 GCCMultiarchTriple, TargetMultiarchTriple,
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00003760 Multilib.includeSuffix(), DriverArgs, CC1Args))
Dmitri Gribenko15225ae2013-03-06 17:14:05 +00003761 return;
3762
Chandler Carruthc44f4d42014-08-27 08:41:41 +00003763 // Otherwise, fall back on a bunch of options which don't use multiarch
3764 // layouts for simplicity.
Chandler Carruth5a3d8982014-01-20 09:42:24 +00003765 const std::string LibStdCXXIncludePathCandidates[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003766 // Gentoo is weird and places its headers inside the GCC install,
3767 // so if the first attempt to find the headers fails, try these patterns.
3768 InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
3769 Version.MinorStr,
3770 InstallDir.str() + "/include/g++-v" + Version.MajorStr,
3771 // Android standalone toolchain has C++ headers in yet another place.
3772 LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
3773 // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
3774 // without a subdirectory corresponding to the gcc version.
3775 LibDir.str() + "/../include/c++",
Evgeniy Stepanov763671e2012-09-03 09:05:50 +00003776 };
3777
Simon Atanasyan6f657c42014-05-08 19:32:46 +00003778 for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
Chandler Carruthc44f4d42014-08-27 08:41:41 +00003779 if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
3780 /*GCCMultiarchTriple*/ "",
3781 /*TargetMultiarchTriple*/ "",
3782 Multilib.includeSuffix(), DriverArgs, CC1Args))
Evgeniy Stepanov763671e2012-09-03 09:05:50 +00003783 break;
Chandler Carruthf5d4df92011-11-06 10:31:01 +00003784 }
Chandler Carrutha796f532011-11-05 20:17:13 +00003785}
3786
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003787bool Linux::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003788
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003789SanitizerMask Linux::getSupportedSanitizers() const {
3790 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
3791 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
3792 const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
3793 getTriple().getArch() == llvm::Triple::mips64el;
Jay Foade967dd02015-06-25 10:35:19 +00003794 const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
3795 getTriple().getArch() == llvm::Triple::ppc64le;
Adhemerval Zanella76aee672015-07-30 20:50:39 +00003796 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
3797 getTriple().getArch() == llvm::Triple::aarch64_be;
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003798 SanitizerMask Res = ToolChain::getSupportedSanitizers();
3799 Res |= SanitizerKind::Address;
3800 Res |= SanitizerKind::KernelAddress;
3801 Res |= SanitizerKind::Vptr;
Evgeniy Stepanov299238a2015-09-24 17:22:46 +00003802 Res |= SanitizerKind::SafeStack;
Adhemerval Zanella76aee672015-07-30 20:50:39 +00003803 if (IsX86_64 || IsMIPS64 || IsAArch64)
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003804 Res |= SanitizerKind::DataFlow;
Adhemerval Zanellabffb20d2015-10-05 19:16:42 +00003805 if (IsX86_64 || IsMIPS64 || IsAArch64)
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003806 Res |= SanitizerKind::Leak;
Renato Golind45c2df2015-08-05 18:42:41 +00003807 if (IsX86_64 || IsMIPS64 || IsAArch64)
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003808 Res |= SanitizerKind::Thread;
Adhemerval Zanella567b9262015-09-16 15:11:21 +00003809 if (IsX86_64 || IsMIPS64 || IsPowerPC64 || IsAArch64)
Jay Foade967dd02015-06-25 10:35:19 +00003810 Res |= SanitizerKind::Memory;
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003811 if (IsX86 || IsX86_64) {
3812 Res |= SanitizerKind::Function;
Alexey Samsonov7f2a0d22015-06-19 21:36:47 +00003813 }
3814 return Res;
3815}
3816
Xinliang David Li170cd102015-10-27 05:15:35 +00003817void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
3818 llvm::opt::ArgStringList &CmdArgs) const {
3819 if (!needsProfileRT(Args)) return;
3820
3821 // Add linker option -u__llvm_runtime_variable to cause runtime
3822 // initialization module to be linked in.
3823 if (!Args.hasArg(options::OPT_coverage))
3824 CmdArgs.push_back(Args.MakeArgString(
3825 Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
3826 ToolChain::addProfileRTLibs(Args, CmdArgs);
3827}
3828
Daniel Dunbarcc912342009-05-02 18:28:39 +00003829/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
3830
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003831DragonFly::DragonFly(const Driver &D, const llvm::Triple &Triple,
3832 const ArgList &Args)
3833 : Generic_ELF(D, Triple, Args) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00003834
3835 // Path mangling to find libexec
Daniel Dunbar88979912010-08-01 22:29:51 +00003836 getProgramPaths().push_back(getDriver().getInstalledDir());
Benjamin Kramer51477bd2011-03-01 22:50:47 +00003837 if (getDriver().getInstalledDir() != getDriver().Dir)
Daniel Dunbar88979912010-08-01 22:29:51 +00003838 getProgramPaths().push_back(getDriver().Dir);
Daniel Dunbarcc912342009-05-02 18:28:39 +00003839
Daniel Dunbar083edf72009-12-21 18:54:17 +00003840 getFilePaths().push_back(getDriver().Dir + "/../lib");
Daniel Dunbarcc912342009-05-02 18:28:39 +00003841 getFilePaths().push_back("/usr/lib");
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003842 if (D.getVFS().exists("/usr/lib/gcc47"))
John McCall65b8da02013-04-11 22:55:55 +00003843 getFilePaths().push_back("/usr/lib/gcc47");
3844 else
3845 getFilePaths().push_back("/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00003846}
3847
Rafael Espindola7cf32212013-03-20 03:05:54 +00003848Tool *DragonFly::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00003849 return new tools::dragonfly::Assembler(*this);
Rafael Espindola7cf32212013-03-20 03:05:54 +00003850}
3851
3852Tool *DragonFly::buildLinker() const {
Douglas Katzman95354292015-06-23 20:42:09 +00003853 return new tools::dragonfly::Linker(*this);
Daniel Dunbarcc912342009-05-02 18:28:39 +00003854}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003855
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003856/// Stub for CUDA toolchain. At the moment we don't have assembler or
3857/// linker and need toolchain mainly to propagate device-side options
3858/// to CC1.
3859
3860CudaToolChain::CudaToolChain(const Driver &D, const llvm::Triple &Triple,
3861 const ArgList &Args)
3862 : Linux(D, Triple, Args) {}
3863
3864void
3865CudaToolChain::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
3866 llvm::opt::ArgStringList &CC1Args) const {
3867 Linux::addClangTargetOptions(DriverArgs, CC1Args);
3868 CC1Args.push_back("-fcuda-is-device");
3869}
3870
3871llvm::opt::DerivedArgList *
3872CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
3873 const char *BoundArch) const {
3874 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
3875 const OptTable &Opts = getDriver().getOpts();
3876
3877 for (Arg *A : Args) {
3878 if (A->getOption().matches(options::OPT_Xarch__)) {
3879 // Skip this argument unless the architecture matches BoundArch
3880 if (A->getValue(0) != StringRef(BoundArch))
3881 continue;
3882
3883 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
3884 unsigned Prev = Index;
3885 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
3886
3887 // If the argument parsing failed or more than one argument was
3888 // consumed, the -Xarch_ argument's parameter tried to consume
3889 // extra arguments. Emit an error and ignore.
3890 //
3891 // We also want to disallow any options which would alter the
3892 // driver behavior; that isn't going to work in our model. We
3893 // use isDriverOption() as an approximation, although things
3894 // like -O4 are going to slip through.
3895 if (!XarchArg || Index > Prev + 1) {
3896 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
3897 << A->getAsString(Args);
3898 continue;
3899 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
3900 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
3901 << A->getAsString(Args);
3902 continue;
3903 }
3904 XarchArg->setBaseArg(A);
3905 A = XarchArg.release();
3906 DAL->AddSynthesizedArg(A);
3907 }
3908 DAL->append(A);
3909 }
3910
3911 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
3912 return DAL;
3913}
3914
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003915/// XCore tool chain
Douglas Katzman54366072015-07-27 16:53:08 +00003916XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple,
3917 const ArgList &Args)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003918 : ToolChain(D, Triple, Args) {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003919 // ProgramPaths are found via 'PATH' environment variable.
3920}
3921
Douglas Katzman54366072015-07-27 16:53:08 +00003922Tool *XCoreToolChain::buildAssembler() const {
Douglas Katzman95354292015-06-23 20:42:09 +00003923 return new tools::XCore::Assembler(*this);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003924}
3925
Douglas Katzman54366072015-07-27 16:53:08 +00003926Tool *XCoreToolChain::buildLinker() const {
3927 return new tools::XCore::Linker(*this);
3928}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003929
Douglas Katzman54366072015-07-27 16:53:08 +00003930bool XCoreToolChain::isPICDefault() const { return false; }
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003931
Douglas Katzman54366072015-07-27 16:53:08 +00003932bool XCoreToolChain::isPIEDefault() const { return false; }
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003933
Douglas Katzman54366072015-07-27 16:53:08 +00003934bool XCoreToolChain::isPICDefaultForced() const { return false; }
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003935
Douglas Katzman54366072015-07-27 16:53:08 +00003936bool XCoreToolChain::SupportsProfiling() const { return false; }
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003937
Douglas Katzman54366072015-07-27 16:53:08 +00003938bool XCoreToolChain::hasBlocksRuntime() const { return false; }
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003939
Douglas Katzman54366072015-07-27 16:53:08 +00003940void XCoreToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
3941 ArgStringList &CC1Args) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003942 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
3943 DriverArgs.hasArg(options::OPT_nostdlibinc))
3944 return;
3945 if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) {
3946 SmallVector<StringRef, 4> Dirs;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003947 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003948 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
3949 ArrayRef<StringRef> DirVec(Dirs);
3950 addSystemIncludes(DriverArgs, CC1Args, DirVec);
3951 }
3952}
3953
Douglas Katzman54366072015-07-27 16:53:08 +00003954void XCoreToolChain::addClangTargetOptions(const ArgList &DriverArgs,
3955 ArgStringList &CC1Args) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003956 CC1Args.push_back("-nostdsysteminc");
3957}
3958
Douglas Katzman54366072015-07-27 16:53:08 +00003959void XCoreToolChain::AddClangCXXStdlibIncludeArgs(
3960 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003961 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
Robert Lyttonf9710b32014-08-01 13:11:46 +00003962 DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3963 DriverArgs.hasArg(options::OPT_nostdincxx))
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003964 return;
3965 if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) {
3966 SmallVector<StringRef, 4> Dirs;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003967 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003968 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
3969 ArrayRef<StringRef> DirVec(Dirs);
3970 addSystemIncludes(DriverArgs, CC1Args, DirVec);
3971 }
3972}
3973
Douglas Katzman54366072015-07-27 16:53:08 +00003974void XCoreToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
3975 ArgStringList &CmdArgs) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00003976 // We don't output any lib args. This is handled by xcc.
3977}
Douglas Katzman84a75642015-06-19 14:55:19 +00003978
Douglas Katzmand6e597c2015-09-17 19:56:40 +00003979MyriadToolChain::MyriadToolChain(const Driver &D, const llvm::Triple &Triple,
3980 const ArgList &Args)
3981 : Generic_GCC(D, Triple, Args) {
3982 // If a target of 'sparc-myriad-elf' is specified to clang, it wants to use
3983 // 'sparc-myriad--elf' (note the unknown OS) as the canonical triple.
3984 // This won't work to find gcc. Instead we give the installation detector an
3985 // extra triple, which is preferable to further hacks of the logic that at
3986 // present is based solely on getArch(). In particular, it would be wrong to
3987 // choose the myriad installation when targeting a non-myriad sparc install.
3988 switch (Triple.getArch()) {
3989 default:
3990 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName() << "myriad";
3991 case llvm::Triple::sparc:
3992 case llvm::Triple::sparcel:
3993 case llvm::Triple::shave:
Benjamin Kramerd45b2052015-10-07 15:48:01 +00003994 GCCInstallation.init(Triple, Args, {"sparc-myriad-elf"});
Douglas Katzmand6e597c2015-09-17 19:56:40 +00003995 }
3996}
3997
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00003998MyriadToolChain::~MyriadToolChain() {}
Douglas Katzmand6e597c2015-09-17 19:56:40 +00003999
Douglas Katzmanb1278f32015-09-17 21:20:16 +00004000void MyriadToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4001 ArgStringList &CC1Args) const {
4002 if (!DriverArgs.hasArg(options::OPT_nostdinc))
4003 addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
4004}
4005
James Y Knighta6c9ee72015-10-16 18:46:26 +00004006void MyriadToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
4007 ArgStringList &CC1Args) const {
4008 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4009 DriverArgs.hasArg(options::OPT_nostdincxx))
4010 return;
4011
4012 // Only libstdc++, for now.
4013 StringRef LibDir = GCCInstallation.getParentLibPath();
4014 const GCCVersion &Version = GCCInstallation.getVersion();
4015 StringRef TripleStr = GCCInstallation.getTriple().str();
4016 const Multilib &Multilib = GCCInstallation.getMultilib();
4017
4018 addLibStdCXXIncludePaths(LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4019 "", TripleStr, "", "", Multilib.includeSuffix(), DriverArgs, CC1Args);
4020}
4021
Douglas Katzmand6e597c2015-09-17 19:56:40 +00004022// MyriadToolChain handles several triples:
4023// {shave,sparc{,el}}-myriad-{rtems,unknown}-elf
4024Tool *MyriadToolChain::SelectTool(const JobAction &JA) const {
4025 // The inherited method works fine if not targeting the SHAVE.
4026 if (!isShaveCompilation(getTriple()))
4027 return ToolChain::SelectTool(JA);
Douglas Katzman84a75642015-06-19 14:55:19 +00004028 switch (JA.getKind()) {
4029 case Action::CompileJobClass:
4030 if (!Compiler)
Douglas Katzman95354292015-06-23 20:42:09 +00004031 Compiler.reset(new tools::SHAVE::Compiler(*this));
Douglas Katzman84a75642015-06-19 14:55:19 +00004032 return Compiler.get();
4033 case Action::AssembleJobClass:
4034 if (!Assembler)
Douglas Katzman95354292015-06-23 20:42:09 +00004035 Assembler.reset(new tools::SHAVE::Assembler(*this));
Douglas Katzman84a75642015-06-19 14:55:19 +00004036 return Assembler.get();
4037 default:
4038 return ToolChain::getTool(JA.getKind());
4039 }
4040}
4041
Douglas Katzmand6e597c2015-09-17 19:56:40 +00004042void MyriadToolChain::getCompilerSupportDir(std::string &Dir) const {
4043 // This directory contains crt{i,n,begin,end}.o as well as libgcc.
4044 // These files are tied to a particular version of gcc.
4045 SmallString<128> Result(GCCInstallation.getInstallPath());
4046 // There are actually 4 choices: {le,be} x {fpu,nofpu}
4047 // but as this toolchain is for LEON sparc, it can assume FPU.
4048 if (this->getTriple().getArch() == llvm::Triple::sparcel)
4049 llvm::sys::path::append(Result, "le");
4050 Dir.assign(Result.str());
4051}
4052void MyriadToolChain::getBuiltinLibDir(std::string &Dir) const {
4053 // The contents of LibDir are independent of the version of gcc.
4054 // This contains libc, libg (a superset of libc), libm, libstdc++, libssp.
4055 SmallString<128> Result(GCCInstallation.getParentLibPath());
4056 if (this->getTriple().getArch() == llvm::Triple::sparcel)
4057 llvm::sys::path::append(Result, "../sparc-myriad-elf/lib/le");
4058 else
4059 llvm::sys::path::append(Result, "../sparc-myriad-elf/lib");
4060 Dir.assign(Result.str());
Douglas Katzman84a75642015-06-19 14:55:19 +00004061}
4062
Douglas Katzmand6e597c2015-09-17 19:56:40 +00004063Tool *MyriadToolChain::buildLinker() const {
4064 return new tools::Myriad::Linker(*this);
Douglas Katzman84a75642015-06-19 14:55:19 +00004065}
Dan Gohmanc2853072015-09-03 22:51:53 +00004066
4067bool WebAssembly::IsMathErrnoDefault() const { return false; }
4068
4069bool WebAssembly::IsObjCNonFragileABIDefault() const { return true; }
4070
4071bool WebAssembly::UseObjCMixedDispatch() const { return true; }
4072
4073bool WebAssembly::isPICDefault() const { return false; }
4074
4075bool WebAssembly::isPIEDefault() const { return false; }
4076
4077bool WebAssembly::isPICDefaultForced() const { return false; }
4078
4079bool WebAssembly::IsIntegratedAssemblerDefault() const { return true; }
4080
4081// TODO: Support Objective C stuff.
4082bool WebAssembly::SupportsObjCGC() const { return false; }
4083
4084bool WebAssembly::hasBlocksRuntime() const { return false; }
4085
4086// TODO: Support profiling.
4087bool WebAssembly::SupportsProfiling() const { return false; }
4088
4089void WebAssembly::addClangTargetOptions(const ArgList &DriverArgs,
4090 ArgStringList &CC1Args) const {
4091 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
4092 options::OPT_fno_use_init_array, true))
4093 CC1Args.push_back("-fuse-init-array");
4094}
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004095
4096PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
4097 : Generic_ELF(D, Triple, Args) {
4098 if (Args.hasArg(options::OPT_static))
4099 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-static" << "PS4";
4100
4101 // Determine where to find the PS4 libraries. We use SCE_PS4_SDK_DIR
4102 // if it exists; otherwise use the driver's installation path, which
4103 // should be <SDK_DIR>/host_tools/bin.
4104
4105 SmallString<512> PS4SDKDir;
4106 if (const char *EnvValue = getenv("SCE_PS4_SDK_DIR")) {
4107 if (!llvm::sys::fs::exists(EnvValue))
4108 getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
4109 PS4SDKDir = EnvValue;
4110 } else {
4111 PS4SDKDir = getDriver().Dir;
4112 llvm::sys::path::append(PS4SDKDir, "/../../");
4113 }
4114
4115 // By default, the driver won't report a warning if it can't find
4116 // PS4's include or lib directories. This behavior could be changed if
4117 // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
4118 // If -isysroot was passed, use that as the SDK base path.
4119 std::string PrefixDir;
4120 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4121 PrefixDir = A->getValue();
4122 if (!llvm::sys::fs::exists(PrefixDir))
4123 getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
4124 } else
4125 PrefixDir = PS4SDKDir.str();
4126
4127 SmallString<512> PS4SDKIncludeDir(PrefixDir);
4128 llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
4129 if (!Args.hasArg(options::OPT_nostdinc) &&
4130 !Args.hasArg(options::OPT_nostdlibinc) &&
4131 !Args.hasArg(options::OPT_isysroot) &&
4132 !Args.hasArg(options::OPT__sysroot_EQ) &&
4133 !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
4134 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
4135 << "PS4 system headers" << PS4SDKIncludeDir;
4136 }
4137
4138 SmallString<512> PS4SDKLibDir(PS4SDKDir);
4139 llvm::sys::path::append(PS4SDKLibDir, "target/lib");
4140 if (!Args.hasArg(options::OPT_nostdlib) &&
4141 !Args.hasArg(options::OPT_nodefaultlibs) &&
4142 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
4143 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
4144 !Args.hasArg(options::OPT_emit_ast) &&
4145 !llvm::sys::fs::exists(PS4SDKLibDir)) {
4146 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
4147 << "PS4 system libraries" << PS4SDKLibDir;
4148 return;
4149 }
4150 getFilePaths().push_back(PS4SDKLibDir.str());
4151}
4152
4153Tool *PS4CPU::buildAssembler() const {
4154 return new tools::PS4cpu::Assemble(*this);
4155}
4156
4157Tool *PS4CPU::buildLinker() const { return new tools::PS4cpu::Link(*this); }
4158
4159bool PS4CPU::isPICDefault() const { return true; }
4160
4161bool PS4CPU::HasNativeLLVMSupport() const { return true; }
4162
4163SanitizerMask PS4CPU::getSupportedSanitizers() const {
4164 SanitizerMask Res = ToolChain::getSupportedSanitizers();
4165 Res |= SanitizerKind::Address;
4166 Res |= SanitizerKind::Vptr;
4167 return Res;
4168}