blob: 5322a6dae2c3355d10ff5ee1cf1cc8cd037d3d5d [file] [log] [blame]
Nick Lewycky3fdcc6f2010-12-31 17:31:54 +00001//===--- ToolChain.cpp - Collections of tools for one platform ------------===//
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +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
Rafael Espindola5b222052013-03-18 20:48:54 +000010#include "Tools.h"
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000011#include "clang/Driver/ToolChain.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000012#include "clang/Basic/ObjCRuntime.h"
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000013#include "clang/Driver/Action.h"
Daniel Dunbar00577ad2010-08-23 22:35:37 +000014#include "clang/Driver/Arg.h"
15#include "clang/Driver/ArgList.h"
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000016#include "clang/Driver/Driver.h"
Daniel Dunbar00577ad2010-08-23 22:35:37 +000017#include "clang/Driver/DriverDiagnostic.h"
Benjamin Kramere20e5082012-10-04 19:42:20 +000018#include "clang/Driver/Option.h"
Daniel Dunbar00577ad2010-08-23 22:35:37 +000019#include "clang/Driver/Options.h"
Bob Wilson57f6d192012-03-21 17:19:12 +000020#include "llvm/ADT/StringSwitch.h"
John McCall9f084a32011-07-06 00:26:06 +000021#include "llvm/Support/ErrorHandling.h"
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000022using namespace clang::driver;
Chris Lattner5f9e2722011-07-23 10:55:15 +000023using namespace clang;
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000024
Rafael Espindolaaf370e62013-03-18 18:10:27 +000025ToolChain::ToolChain(const Driver &D, const llvm::Triple &T,
26 const ArgList &A)
27 : D(D), Triple(T), Args(A) {
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000028}
29
30ToolChain::~ToolChain() {
Rafael Espindola5b222052013-03-18 20:48:54 +000031 // Free tool implementations.
32 for (llvm::DenseMap<unsigned, Tool*>::iterator
33 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
34 delete it->second;
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000035}
36
Daniel Dunbaree788e72009-12-21 18:54:17 +000037const Driver &ToolChain::getDriver() const {
Chandler Carruth4d7ff6e2012-01-25 09:12:06 +000038 return D;
Daniel Dunbaree788e72009-12-21 18:54:17 +000039}
40
Rafael Espindolaaf370e62013-03-18 18:10:27 +000041bool ToolChain::useIntegratedAs() const {
Rafael Espindola5470cd22013-03-18 17:52:57 +000042 return Args.hasFlag(options::OPT_integrated_as,
43 options::OPT_no_integrated_as,
44 IsIntegratedAssemblerDefault());
45}
46
Daniel Dunbard2a527e2012-11-08 03:38:26 +000047std::string ToolChain::getDefaultUniversalArchName() const {
48 // In universal driver terms, the arch name accepted by -arch isn't exactly
49 // the same as the ones that appear in the triple. Roughly speaking, this is
50 // an inverse of the darwin::getArchTypeForDarwinArchName() function, but the
51 // only interesting special case is powerpc.
52 switch (Triple.getArch()) {
53 case llvm::Triple::ppc:
54 return "ppc";
55 case llvm::Triple::ppc64:
56 return "ppc64";
57 default:
58 return Triple.getArchName();
59 }
60}
61
Rafael Espindola03a86382012-09-23 03:05:41 +000062bool ToolChain::IsUnwindTablesDefault() const {
63 return false;
64}
65
Rafael Espindola5b222052013-03-18 20:48:54 +000066Tool &ToolChain::SelectTool(const JobAction &JA) const {
67 Action::ActionClass Key;
68 if (getDriver().ShouldUseClangCompiler(JA))
69 Key = Action::AnalyzeJobClass;
70 else
71 Key = JA.getKind();
72
73 Tool *&T = Tools[Key];
74 if (T)
75 return *T;
76
77 if (getDriver().ShouldUseClangCompiler(JA))
78 T = new tools::Clang(*this);
Rafael Espindola8a1115f2013-03-18 23:56:07 +000079 else if (Key == Action::AssembleJobClass && useIntegratedAs())
80 T = new tools::ClangAs(*this);
Rafael Espindola5b222052013-03-18 20:48:54 +000081 else
82 T = constructTool(Key);
83
84 return *T;
85}
86
Daniel Dunbar4a7e8892010-07-14 18:46:23 +000087std::string ToolChain::GetFilePath(const char *Name) const {
Chandler Carruth4d7ff6e2012-01-25 09:12:06 +000088 return D.GetFilePath(Name, *this);
Mike Stump1eb44332009-09-09 15:08:12 +000089
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000090}
91
Simon Atanasyanfc44e882012-10-03 19:52:37 +000092std::string ToolChain::GetProgramPath(const char *Name) const {
93 return D.GetProgramPath(Name, *this);
Daniel Dunbar2ba38ba2009-03-16 05:25:36 +000094}
Daniel Dunbar41800112010-08-02 05:43:56 +000095
96types::ID ToolChain::LookupTypeForExtension(const char *Ext) const {
97 return types::lookupTypeForExtension(Ext);
98}
Daniel Dunbar00577ad2010-08-23 22:35:37 +000099
Daniel Dunbarb993f5d2010-09-17 00:24:52 +0000100bool ToolChain::HasNativeLLVMSupport() const {
101 return false;
102}
103
John McCall260611a2012-06-20 06:18:46 +0000104ObjCRuntime ToolChain::getDefaultObjCRuntime(bool isNonFragile) const {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000105 return ObjCRuntime(isNonFragile ? ObjCRuntime::GNUstep : ObjCRuntime::GCC,
John McCall260611a2012-06-20 06:18:46 +0000106 VersionTuple());
John McCall9f084a32011-07-06 00:26:06 +0000107}
108
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000109/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000110//
111// FIXME: tblgen this.
112static const char *getARMTargetCPU(const ArgList &Args,
113 const llvm::Triple &Triple) {
Bob Wilson677a35b2012-03-21 16:31:37 +0000114 // For Darwin targets, the -arch option (which is translated to a
115 // corresponding -march option) should determine the architecture
116 // (and the Mach-O slice) regardless of any -mcpu options.
117 if (!Triple.isOSDarwin()) {
118 // FIXME: Warn on inconsistent use of -mcpu and -march.
119 // If we have -mcpu=, use that.
120 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Richard Smith1d489cf2012-11-01 04:30:05 +0000121 return A->getValue();
Bob Wilson677a35b2012-03-21 16:31:37 +0000122 }
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000123
Chris Lattner5f9e2722011-07-23 10:55:15 +0000124 StringRef MArch;
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000125 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
126 // Otherwise, if we have -march= choose the base CPU for that arch.
Richard Smith1d489cf2012-11-01 04:30:05 +0000127 MArch = A->getValue();
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000128 } else {
129 // Otherwise, use the Arch from the triple.
130 MArch = Triple.getArchName();
131 }
132
Bob Wilson57f6d192012-03-21 17:19:12 +0000133 return llvm::StringSwitch<const char *>(MArch)
134 .Cases("armv2", "armv2a","arm2")
135 .Case("armv3", "arm6")
136 .Case("armv3m", "arm7m")
137 .Cases("armv4", "armv4t", "arm7tdmi")
138 .Cases("armv5", "armv5t", "arm10tdmi")
139 .Cases("armv5e", "armv5te", "arm1026ejs")
140 .Case("armv5tej", "arm926ej-s")
141 .Cases("armv6", "armv6k", "arm1136jf-s")
142 .Case("armv6j", "arm1136j-s")
143 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
144 .Case("armv6t2", "arm1156t2-s")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000145 .Cases("armv6m", "armv6-m", "cortex-m0")
Bob Wilson57f6d192012-03-21 17:19:12 +0000146 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
Renato Golin40a94e22013-02-05 23:42:01 +0000147 .Cases("armv7l", "armv7-l", "cortex-a8")
Bob Wilson336bfa32012-09-29 23:52:50 +0000148 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
149 .Cases("armv7s", "armv7-s", "swift")
Bob Wilson532f5a92013-03-04 22:37:43 +0000150 .Cases("armv7r", "armv7-r", "cortex-r4")
Bob Wilson57f6d192012-03-21 17:19:12 +0000151 .Cases("armv7m", "armv7-m", "cortex-m3")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000152 .Cases("armv7em", "armv7e-m", "cortex-m4")
Bob Wilson57f6d192012-03-21 17:19:12 +0000153 .Case("ep9312", "ep9312")
154 .Case("iwmmxt", "iwmmxt")
155 .Case("xscale", "xscale")
Bob Wilson57f6d192012-03-21 17:19:12 +0000156 // If all else failed, return the most base CPU LLVM supports.
157 .Default("arm7tdmi");
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000158}
159
160/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
161/// CPU.
162//
163// FIXME: This is redundant with -mcpu, why does LLVM use this.
164// FIXME: tblgen this, or kill it!
Chris Lattner5f9e2722011-07-23 10:55:15 +0000165static const char *getLLVMArchSuffixForARM(StringRef CPU) {
Bob Wilson57f6d192012-03-21 17:19:12 +0000166 return llvm::StringSwitch<const char *>(CPU)
167 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
168 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
169 .Cases("arm920", "arm920t", "arm922t", "v4t")
170 .Cases("arm940t", "ep9312","v4t")
171 .Cases("arm10tdmi", "arm1020t", "v5")
172 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
173 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
174 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
175 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
176 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
177 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonfc553452013-03-04 22:37:46 +0000178 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
179 .Cases("cortex-a9", "cortex-a15", "v7")
180 .Case("cortex-r5", "v7r")
Bob Wilson57f6d192012-03-21 17:19:12 +0000181 .Case("cortex-m0", "v6m")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000182 .Case("cortex-m3", "v7m")
183 .Case("cortex-m4", "v7em")
Bob Wilson336bfa32012-09-29 23:52:50 +0000184 .Case("cortex-a9-mp", "v7f")
185 .Case("swift", "v7s")
Bob Wilson57f6d192012-03-21 17:19:12 +0000186 .Default("");
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000187}
188
Chad Rosier61ab80a2011-09-20 20:44:06 +0000189std::string ToolChain::ComputeLLVMTriple(const ArgList &Args,
190 types::ID InputType) const {
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000191 switch (getTriple().getArch()) {
192 default:
193 return getTripleString();
194
195 case llvm::Triple::arm:
196 case llvm::Triple::thumb: {
197 // FIXME: Factor into subclasses.
198 llvm::Triple Triple = getTriple();
199
200 // Thumb2 is the default for V7 on Darwin.
201 //
202 // FIXME: Thumb should just be another -target-feaure, not in the triple.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000203 StringRef Suffix =
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000204 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Bob Wilson2503ebd2013-03-04 22:37:49 +0000205 bool ThumbDefault = Suffix.startswith("v6m") ||
206 (Suffix.startswith("v7") && getTriple().isOSDarwin());
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000207 std::string ArchName = "arm";
Chad Rosier61ab80a2011-09-20 20:44:06 +0000208
209 // Assembly files should start in ARM mode.
210 if (InputType != types::TY_PP_Asm &&
211 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault))
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000212 ArchName = "thumb";
213 Triple.setArchName(ArchName + Suffix.str());
214
215 return Triple.getTriple();
216 }
217 }
218}
219
Chad Rosier61ab80a2011-09-20 20:44:06 +0000220std::string ToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
221 types::ID InputType) const {
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000222 // Diagnose use of Darwin OS deployment target arguments on non-Darwin.
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000223 if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ,
Daniel Dunbar9d609f22011-04-30 04:15:58 +0000224 options::OPT_miphoneos_version_min_EQ,
225 options::OPT_mios_simulator_version_min_EQ))
Chris Lattner5f9e2722011-07-23 10:55:15 +0000226 getDriver().Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000227 << A->getAsString(Args);
228
Chad Rosier61ab80a2011-09-20 20:44:06 +0000229 return ComputeLLVMTriple(Args, InputType);
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000230}
231
Chandler Carruth88491fc2011-11-04 07:12:53 +0000232void ToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
233 ArgStringList &CC1Args) const {
234 // Each toolchain should provide the appropriate include flags.
235}
236
Chandler Carrutha6b25812012-11-21 23:40:23 +0000237void ToolChain::addClangTargetOptions(const ArgList &DriverArgs,
238 ArgStringList &CC1Args) const {
Rafael Espindola8af669f2012-06-19 01:26:10 +0000239}
240
Daniel Dunbarc24767c2011-12-07 23:03:15 +0000241ToolChain::RuntimeLibType ToolChain::GetRuntimeLibType(
242 const ArgList &Args) const
243{
244 if (Arg *A = Args.getLastArg(options::OPT_rtlib_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000245 StringRef Value = A->getValue();
Daniel Dunbarc24767c2011-12-07 23:03:15 +0000246 if (Value == "compiler-rt")
247 return ToolChain::RLT_CompilerRT;
248 if (Value == "libgcc")
249 return ToolChain::RLT_Libgcc;
250 getDriver().Diag(diag::err_drv_invalid_rtlib_name)
251 << A->getAsString(Args);
252 }
253
254 return GetDefaultRuntimeLibType();
255}
256
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000257ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{
Daniel Dunbar3f16c952010-09-14 23:12:40 +0000258 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000259 StringRef Value = A->getValue();
Daniel Dunbar3f16c952010-09-14 23:12:40 +0000260 if (Value == "libc++")
261 return ToolChain::CST_Libcxx;
262 if (Value == "libstdc++")
263 return ToolChain::CST_Libstdcxx;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000264 getDriver().Diag(diag::err_drv_invalid_stdlib_name)
Daniel Dunbar3f16c952010-09-14 23:12:40 +0000265 << A->getAsString(Args);
266 }
267
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000268 return ToolChain::CST_Libstdcxx;
269}
270
Chandler Carruth79cbbdc2011-12-17 23:10:01 +0000271/// \brief Utility function to add a system include directory to CC1 arguments.
272/*static*/ void ToolChain::addSystemInclude(const ArgList &DriverArgs,
273 ArgStringList &CC1Args,
274 const Twine &Path) {
275 CC1Args.push_back("-internal-isystem");
276 CC1Args.push_back(DriverArgs.MakeArgString(Path));
277}
278
279/// \brief Utility function to add a system include directory with extern "C"
280/// semantics to CC1 arguments.
281///
282/// Note that this should be used rarely, and only for directories that
283/// historically and for legacy reasons are treated as having implicit extern
284/// "C" semantics. These semantics are *ignored* by and large today, but its
285/// important to preserve the preprocessor changes resulting from the
286/// classification.
287/*static*/ void ToolChain::addExternCSystemInclude(const ArgList &DriverArgs,
288 ArgStringList &CC1Args,
289 const Twine &Path) {
290 CC1Args.push_back("-internal-externc-isystem");
291 CC1Args.push_back(DriverArgs.MakeArgString(Path));
292}
293
294/// \brief Utility function to add a list of system include directories to CC1.
295/*static*/ void ToolChain::addSystemIncludes(const ArgList &DriverArgs,
296 ArgStringList &CC1Args,
297 ArrayRef<StringRef> Paths) {
298 for (ArrayRef<StringRef>::iterator I = Paths.begin(), E = Paths.end();
299 I != E; ++I) {
300 CC1Args.push_back("-internal-isystem");
301 CC1Args.push_back(DriverArgs.MakeArgString(*I));
302 }
303}
304
Chandler Carruthab9fcd02011-11-04 23:49:01 +0000305void ToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
306 ArgStringList &CC1Args) const {
Chandler Carrutha4614422011-11-04 07:43:33 +0000307 // Header search paths should be handled by each of the subclasses.
308 // Historically, they have not been, and instead have been handled inside of
309 // the CC1-layer frontend. As the logic is hoisted out, this generic function
310 // will slowly stop being called.
311 //
312 // While it is being called, replicate a bit of a hack to propagate the
313 // '-stdlib=' flag down to CC1 so that it can in turn customize the C++
314 // header search paths with it. Once all systems are overriding this
315 // function, the CC1 flag and this line can be removed.
Chandler Carruthab9fcd02011-11-04 23:49:01 +0000316 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000317}
318
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000319void ToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
320 ArgStringList &CmdArgs) const {
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000321 CXXStdlibType Type = GetCXXStdlibType(Args);
322
323 switch (Type) {
Daniel Dunbar3f16c952010-09-14 23:12:40 +0000324 case ToolChain::CST_Libcxx:
325 CmdArgs.push_back("-lc++");
326 break;
327
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000328 case ToolChain::CST_Libstdcxx:
329 CmdArgs.push_back("-lstdc++");
330 break;
331 }
332}
Shantonu Sen7433fed2010-09-17 18:39:08 +0000333
334void ToolChain::AddCCKextLibArgs(const ArgList &Args,
335 ArgStringList &CmdArgs) const {
336 CmdArgs.push_back("-lcc_kext");
337}
Benjamin Kramere20e5082012-10-04 19:42:20 +0000338
339bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args,
340 ArgStringList &CmdArgs) const {
341 // Check if -ffast-math or -funsafe-math is enabled.
342 Arg *A = Args.getLastArg(options::OPT_ffast_math,
343 options::OPT_fno_fast_math,
344 options::OPT_funsafe_math_optimizations,
345 options::OPT_fno_unsafe_math_optimizations);
346
347 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
348 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
349 return false;
350
351 // If crtfastmath.o exists add it to the arguments.
352 std::string Path = GetFilePath("crtfastmath.o");
353 if (Path == "crtfastmath.o") // Not found.
354 return false;
355
356 CmdArgs.push_back(Args.MakeArgString(Path));
357 return true;
358}