blob: 2fb865e020759d00a862f125002d1b173df1e0e8 [file] [log] [blame]
Nick Lewyckye3365aa2010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar47ac7d22009-03-18 06:00: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
10#include "Tools.h"
11
Daniel Dunbar1d460332009-03-18 10:01:51 +000012#include "clang/Driver/Action.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000013#include "clang/Driver/Arg.h"
Daniel Dunbarb488c1d2009-03-18 08:07:30 +000014#include "clang/Driver/ArgList.h"
Daniel Dunbaree848a72009-10-29 02:39:57 +000015#include "clang/Driver/Driver.h"
16#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000017#include "clang/Driver/Compilation.h"
18#include "clang/Driver/Job.h"
Daniel Dunbarb488c1d2009-03-18 08:07:30 +000019#include "clang/Driver/HostInfo.h"
John McCall9f084a32011-07-06 00:26:06 +000020#include "clang/Driver/ObjCRuntime.h"
Daniel Dunbarb488c1d2009-03-18 08:07:30 +000021#include "clang/Driver/Option.h"
Daniel Dunbar265e9ef2009-11-19 04:25:22 +000022#include "clang/Driver/Options.h"
Daniel Dunbarb488c1d2009-03-18 08:07:30 +000023#include "clang/Driver/ToolChain.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000024#include "clang/Driver/Util.h"
25
Daniel Dunbar88137642009-09-09 22:32:48 +000026#include "llvm/ADT/SmallString.h"
Douglas Gregor55d3f7a2009-10-29 00:41:01 +000027#include "llvm/ADT/StringSwitch.h"
Daniel Dunbar5b750fe2009-09-09 22:32:34 +000028#include "llvm/ADT/Twine.h"
Michael J. Spencer32bef4e2011-01-10 02:34:13 +000029#include "llvm/Support/FileSystem.h"
Daniel Dunbar02633b52009-03-26 16:23:12 +000030#include "llvm/Support/Format.h"
31#include "llvm/Support/raw_ostream.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000032#include "llvm/Support/Host.h"
33#include "llvm/Support/Process.h"
John McCallf85e1932011-06-15 23:02:42 +000034#include "llvm/Support/ErrorHandling.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000035
36#include "InputInfo.h"
Daniel Dunbar02633b52009-03-26 16:23:12 +000037#include "ToolChains.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000038
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +000039#ifdef __CYGWIN__
40#include <cygwin/version.h>
41#if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
42#define IS_CYGWIN15 1
43#endif
44#endif
45
Daniel Dunbar47ac7d22009-03-18 06:00:36 +000046using namespace clang::driver;
47using namespace clang::driver::tools;
48
Joerg Sonnenberger10c64352011-03-21 14:01:40 +000049/// FindTargetProgramPath - Return path of the target specific version of
50/// ProgName. If it doesn't exist, return path of ProgName itself.
51static std::string FindTargetProgramPath(const ToolChain &TheToolChain,
Joerg Sonnenberger182564c2011-05-16 13:35:02 +000052 const std::string TripleString,
Joerg Sonnenberger10c64352011-03-21 14:01:40 +000053 const char *ProgName) {
Joerg Sonnenberger182564c2011-05-16 13:35:02 +000054 std::string Executable(TripleString + "-" + ProgName);
Joerg Sonnenberger10c64352011-03-21 14:01:40 +000055 std::string Path(TheToolChain.GetProgramPath(Executable.c_str()));
56 if (Path != Executable)
57 return Path;
58 return TheToolChain.GetProgramPath(ProgName);
59}
60
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +000061/// CheckPreprocessingOptions - Perform some validation of preprocessing
62/// arguments that is shared with gcc.
63static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
64 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Joerg Sonnenberger9ade4ae2011-03-06 23:31:01 +000065 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +000066 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
67 << A->getAsString(Args) << "-E";
68}
69
Daniel Dunbare2fd6642009-09-10 01:21:12 +000070/// CheckCodeGenerationOptions - Perform some validation of code generation
71/// arguments that is shared with gcc.
72static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
73 // In gcc, only ARM checks this, but it seems reasonable to check universally.
74 if (Args.hasArg(options::OPT_static))
75 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
76 options::OPT_mdynamic_no_pic))
77 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
78 << A->getAsString(Args) << "-static";
79}
80
Chris Lattner3edbeb72010-03-29 17:55:58 +000081// Quote target names for inclusion in GNU Make dependency files.
82// Only the characters '$', '#', ' ', '\t' are quoted.
83static void QuoteTarget(llvm::StringRef Target,
84 llvm::SmallVectorImpl<char> &Res) {
85 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
86 switch (Target[i]) {
87 case ' ':
88 case '\t':
89 // Escape the preceding backslashes
90 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
91 Res.push_back('\\');
92
93 // Escape the space/tab
94 Res.push_back('\\');
95 break;
96 case '$':
97 Res.push_back('$');
98 break;
99 case '#':
100 Res.push_back('\\');
101 break;
102 default:
103 break;
104 }
105
106 Res.push_back(Target[i]);
107 }
108}
109
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000110static void AddLinkerInputs(const ToolChain &TC,
111 const InputInfoList &Inputs, const ArgList &Args,
112 ArgStringList &CmdArgs) {
113 const Driver &D = TC.getDriver();
114
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000115 // Add extra linker input arguments which are not treated as inputs
116 // (constructed via -Xarch_).
117 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
118
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000119 for (InputInfoList::const_iterator
120 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
121 const InputInfo &II = *it;
122
123 if (!TC.HasNativeLLVMSupport()) {
124 // Don't try to pass LLVM inputs unless we have native support.
125 if (II.getType() == types::TY_LLVM_IR ||
126 II.getType() == types::TY_LTO_IR ||
127 II.getType() == types::TY_LLVM_BC ||
128 II.getType() == types::TY_LTO_BC)
129 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
130 << TC.getTripleString();
131 }
132
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000133 // Add filenames immediately.
134 if (II.isFilename()) {
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000135 CmdArgs.push_back(II.getFilename());
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000136 continue;
137 }
138
139 // Otherwise, this is a linker input argument.
140 const Arg &A = II.getInputArg();
141
142 // Handle reserved library options.
143 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000144 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Sen7433fed2010-09-17 18:39:08 +0000145 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
146 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000147 } else
148 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000149 }
150}
151
John McCallf85e1932011-06-15 23:02:42 +0000152/// \brief Determine whether Objective-C automated reference counting is
153/// enabled.
154static bool isObjCAutoRefCount(const ArgList &Args) {
155 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
156}
157
Rafael Espindoladb3f24a2011-06-02 18:58:46 +0000158static void addProfileRT(const ToolChain &TC, const ArgList &Args,
Bill Wendling3f4be6f2011-06-27 19:15:03 +0000159 ArgStringList &CmdArgs,
160 llvm::Triple Triple) {
161 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
162 Args.hasArg(options::OPT_fprofile_generate) ||
163 Args.hasArg(options::OPT_fcreate_profile) ||
164 Args.hasArg(options::OPT_coverage)))
165 return;
166
167 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
168 // the link line. We cannot do the same thing because unlike gcov there is a
169 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
170 // not supported by old linkers.
171 llvm::Twine ProfileRT =
172 llvm::Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.a";
173
174 if (Triple.getOS() == llvm::Triple::Darwin) {
175 // On Darwin, if the static library doesn't exist try the dylib.
176 bool Exists;
177 if (llvm::sys::fs::exists(ProfileRT.str(), Exists) || !Exists)
178 ProfileRT =
179 llvm::Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.dylib";
Rafael Espindoladb3f24a2011-06-02 18:58:46 +0000180 }
Bill Wendling3f4be6f2011-06-27 19:15:03 +0000181
182 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
Rafael Espindoladb3f24a2011-06-02 18:58:46 +0000183}
184
Mike Stump1eb44332009-09-09 15:08:12 +0000185void Clang::AddPreprocessingOptions(const Driver &D,
Douglas Gregordf91ef32009-04-18 00:34:01 +0000186 const ArgList &Args,
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000187 ArgStringList &CmdArgs,
188 const InputInfo &Output,
189 const InputInfoList &Inputs) const {
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000190 Arg *A;
Daniel Dunbar3a183d32009-06-08 21:48:20 +0000191
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +0000192 CheckPreprocessingOptions(D, Args);
193
194 Args.AddLastArg(CmdArgs, options::OPT_C);
195 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar3a183d32009-06-08 21:48:20 +0000196
197 // Handle dependency file generation.
Daniel Dunbar9eb93b02010-12-08 21:33:40 +0000198 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000199 (A = Args.getLastArg(options::OPT_MD)) ||
200 (A = Args.getLastArg(options::OPT_MMD))) {
201 // Determine the output location.
202 const char *DepFile;
203 if (Output.getType() == types::TY_Dependencies) {
Daniel Dunbar7c1e4652010-08-02 02:38:21 +0000204 DepFile = Output.getFilename();
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000205 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
206 DepFile = MF->getValue(Args);
Daniel Dunbarb827a052009-11-19 03:26:40 +0000207 } else if (A->getOption().matches(options::OPT_M) ||
208 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000209 DepFile = "-";
210 } else {
211 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
212 }
213 CmdArgs.push_back("-dependency-file");
214 CmdArgs.push_back(DepFile);
215
Chris Lattner3edbeb72010-03-29 17:55:58 +0000216 // Add a default target if one wasn't specified.
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000217 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
218 const char *DepTarget;
219
220 // If user provided -o, that is the dependency target, except
221 // when we are only generating a dependency file.
222 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
223 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
224 DepTarget = OutputOpt->getValue(Args);
225 } else {
226 // Otherwise derive from the base input.
227 //
228 // FIXME: This should use the computed output file location.
Michael J. Spencer472ccff2010-12-18 00:19:12 +0000229 llvm::SmallString<128> P(Inputs[0].getBaseInput());
230 llvm::sys::path::replace_extension(P, "o");
231 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000232 }
233
234 CmdArgs.push_back("-MT");
Chris Lattner3edbeb72010-03-29 17:55:58 +0000235 llvm::SmallString<128> Quoted;
236 QuoteTarget(DepTarget, Quoted);
237 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000238 }
239
Daniel Dunbarb827a052009-11-19 03:26:40 +0000240 if (A->getOption().matches(options::OPT_M) ||
241 A->getOption().matches(options::OPT_MD))
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000242 CmdArgs.push_back("-sys-header-deps");
243 }
244
Peter Collingbournebb527862011-07-12 19:35:15 +0000245 if (Args.hasArg(options::OPT_MG)) {
246 if (!A || A->getOption().matches(options::OPT_MD) ||
247 A->getOption().matches(options::OPT_MMD))
248 D.Diag(clang::diag::err_drv_mg_requires_m_or_mm);
249 CmdArgs.push_back("-MG");
250 }
251
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000252 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000253
254 // Convert all -MQ <target> args to -MT <quoted target>
255 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
256 options::OPT_MQ),
257 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000258 const Arg *A = *it;
259 A->claim();
Chris Lattner3edbeb72010-03-29 17:55:58 +0000260
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000261 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattner3edbeb72010-03-29 17:55:58 +0000262 CmdArgs.push_back("-MT");
263 llvm::SmallString<128> Quoted;
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000264 QuoteTarget(A->getValue(Args), Quoted);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000265 CmdArgs.push_back(Args.MakeArgString(Quoted));
266
267 // -MT flag - no change
268 } else {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000269 A->render(Args, CmdArgs);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000270 }
271 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000272
Douglas Gregordf91ef32009-04-18 00:34:01 +0000273 // Add -i* options, and automatically translate to
274 // -include-pch/-include-pth for transparent PCH support. It's
275 // wonky, but we include looking for .gch so we can support seamless
276 // replacement into a build system already set up to be generating
277 // .gch files.
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000278 bool RenderedImplicitInclude = false;
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000279 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
280 ie = Args.filtered_end(); it != ie; ++it) {
281 const Arg *A = it;
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000282
283 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000284 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
285 RenderedImplicitInclude = true;
286
Argyrios Kyrtzidise5c35372010-08-11 23:27:58 +0000287 // Use PCH if the user requested it.
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000288 bool UsePCH = D.CCCUsePCH;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000289
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000290 bool FoundPTH = false;
Douglas Gregordf91ef32009-04-18 00:34:01 +0000291 bool FoundPCH = false;
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000292 llvm::sys::Path P(A->getValue(Args));
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000293 bool Exists;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000294 if (UsePCH) {
Douglas Gregordf91ef32009-04-18 00:34:01 +0000295 P.appendSuffix("pch");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000296 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregordf91ef32009-04-18 00:34:01 +0000297 FoundPCH = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000298 else
Douglas Gregordf91ef32009-04-18 00:34:01 +0000299 P.eraseSuffix();
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000300 }
301
Douglas Gregordf91ef32009-04-18 00:34:01 +0000302 if (!FoundPCH) {
303 P.appendSuffix("pth");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000304 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregordf91ef32009-04-18 00:34:01 +0000305 FoundPTH = true;
306 else
307 P.eraseSuffix();
Mike Stump1eb44332009-09-09 15:08:12 +0000308 }
309
Douglas Gregordf91ef32009-04-18 00:34:01 +0000310 if (!FoundPCH && !FoundPTH) {
311 P.appendSuffix("gch");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000312 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000313 FoundPCH = UsePCH;
314 FoundPTH = !UsePCH;
Douglas Gregordf91ef32009-04-18 00:34:01 +0000315 }
Mike Stump1eb44332009-09-09 15:08:12 +0000316 else
Douglas Gregordf91ef32009-04-18 00:34:01 +0000317 P.eraseSuffix();
318 }
319
320 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000321 if (IsFirstImplicitInclude) {
322 A->claim();
323 if (UsePCH)
324 CmdArgs.push_back("-include-pch");
325 else
326 CmdArgs.push_back("-include-pth");
327 CmdArgs.push_back(Args.MakeArgString(P.str()));
328 continue;
329 } else {
330 // Ignore the PCH if not first on command line and emit warning.
331 D.Diag(clang::diag::warn_drv_pch_not_first_include)
332 << P.str() << A->getAsString(Args);
333 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000334 }
335 }
336
337 // Not translated, render as usual.
338 A->claim();
339 A->render(Args, CmdArgs);
340 }
341
342 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
343 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
344
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000345 // Add C++ include arguments, if needed.
346 types::ID InputType = Inputs[0].getType();
John McCallf85e1932011-06-15 23:02:42 +0000347 if (types::isCXX(InputType)) {
348 bool ObjCXXAutoRefCount
349 = types::isObjC(InputType) && isObjCAutoRefCount(Args);
350 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs,
351 ObjCXXAutoRefCount);
Bob Wilson13c4f212011-06-21 21:12:29 +0000352 Args.AddAllArgs(CmdArgs, options::OPT_stdlib_EQ);
John McCallf85e1932011-06-15 23:02:42 +0000353 }
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000354
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000355 // Add -Wp, and -Xassembler if using the preprocessor.
356
357 // FIXME: There is a very unfortunate problem here, some troubled
358 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
359 // really support that we would have to parse and then translate
360 // those options. :(
361 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
362 options::OPT_Xpreprocessor);
Daniel Dunbar607d7f62009-10-29 01:53:44 +0000363
364 // -I- is a deprecated GCC feature, reject it.
365 if (Arg *A = Args.getLastArg(options::OPT_I_))
366 D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruthfeee58c2010-10-20 07:00:47 +0000367
368 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
369 // -isysroot to the CC1 invocation.
370 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
371 if (!Args.hasArg(options::OPT_isysroot)) {
372 CmdArgs.push_back("-isysroot");
373 CmdArgs.push_back(A->getValue(Args));
374 }
375 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000376}
377
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000378/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Daniel Dunbar728a5122009-09-10 06:49:20 +0000379//
380// FIXME: tblgen this.
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000381static const char *getARMTargetCPU(const ArgList &Args,
382 const llvm::Triple &Triple) {
Daniel Dunbar728a5122009-09-10 06:49:20 +0000383 // FIXME: Warn on inconsistent use of -mcpu and -march.
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000384
385 // If we have -mcpu=, use that.
386 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
387 return A->getValue(Args);
388
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000389 llvm::StringRef MArch;
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000390 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000391 // Otherwise, if we have -march= choose the base CPU for that arch.
392 MArch = A->getValue(Args);
393 } else {
394 // Otherwise, use the Arch from the triple.
395 MArch = Triple.getArchName();
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000396 }
397
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000398 if (MArch == "armv2" || MArch == "armv2a")
399 return "arm2";
400 if (MArch == "armv3")
401 return "arm6";
402 if (MArch == "armv3m")
403 return "arm7m";
404 if (MArch == "armv4" || MArch == "armv4t")
405 return "arm7tdmi";
406 if (MArch == "armv5" || MArch == "armv5t")
407 return "arm10tdmi";
408 if (MArch == "armv5e" || MArch == "armv5te")
409 return "arm1026ejs";
410 if (MArch == "armv5tej")
411 return "arm926ej-s";
412 if (MArch == "armv6" || MArch == "armv6k")
413 return "arm1136jf-s";
414 if (MArch == "armv6j")
415 return "arm1136j-s";
416 if (MArch == "armv6z" || MArch == "armv6zk")
417 return "arm1176jzf-s";
418 if (MArch == "armv6t2")
419 return "arm1156t2-s";
420 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
421 return "cortex-a8";
422 if (MArch == "armv7r" || MArch == "armv7-r")
423 return "cortex-r4";
424 if (MArch == "armv7m" || MArch == "armv7-m")
425 return "cortex-m3";
426 if (MArch == "ep9312")
427 return "ep9312";
428 if (MArch == "iwmmxt")
429 return "iwmmxt";
430 if (MArch == "xscale")
431 return "xscale";
Bob Wilson1ec0ade2011-03-21 20:40:05 +0000432 if (MArch == "armv6m" || MArch == "armv6-m")
433 return "cortex-m0";
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000434
435 // If all else failed, return the most base CPU LLVM supports.
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000436 return "arm7tdmi";
437}
438
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000439/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbar728a5122009-09-10 06:49:20 +0000440/// CPU.
441//
442// FIXME: This is redundant with -mcpu, why does LLVM use this.
443// FIXME: tblgen this, or kill it!
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000444static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) {
Daniel Dunbar728a5122009-09-10 06:49:20 +0000445 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" ||
446 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" ||
447 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" ||
448 CPU == "arm940t" || CPU == "ep9312")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000449 return "v4t";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000450
451 if (CPU == "arm10tdmi" || CPU == "arm1020t")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000452 return "v5";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000453
454 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" ||
455 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" ||
456 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" ||
457 CPU == "iwmmxt")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000458 return "v5e";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000459
460 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" ||
461 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000462 return "v6";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000463
464 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000465 return "v6t2";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000466
467 if (CPU == "cortex-a8" || CPU == "cortex-a9")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000468 return "v7";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000469
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000470 return "";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000471}
472
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000473// FIXME: Move to target hook.
474static bool isSignedCharDefault(const llvm::Triple &Triple) {
475 switch (Triple.getArch()) {
476 default:
477 return true;
478
Jim Grosbach5b4e7b12011-05-24 15:40:46 +0000479 case llvm::Triple::arm:
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000480 case llvm::Triple::ppc:
481 case llvm::Triple::ppc64:
482 if (Triple.getOS() == llvm::Triple::Darwin)
483 return true;
484 return false;
485
486 case llvm::Triple::systemz:
487 return false;
488 }
489}
490
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000491void Clang::AddARMTargetArgs(const ArgList &Args,
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000492 ArgStringList &CmdArgs,
493 bool KernelOrKext) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000494 const Driver &D = getToolChain().getDriver();
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000495 llvm::Triple Triple = getToolChain().getTriple();
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000496
Daniel Dunbardb04e2e2011-03-02 00:55:57 +0000497 // Disable movt generation, if requested.
498#ifdef DISABLE_ARM_DARWIN_USE_MOVT
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000499 CmdArgs.push_back("-backend-option");
Daniel Dunbardb04e2e2011-03-02 00:55:57 +0000500 CmdArgs.push_back("-arm-darwin-use-movt=0");
501#endif
502
Daniel Dunbar2030d8f2009-09-14 00:34:46 +0000503 // Select the ABI to use.
504 //
505 // FIXME: Support -meabi.
506 const char *ABIName = 0;
507 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
508 ABIName = A->getValue(Args);
509 } else {
510 // Select the default based on the platform.
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000511 switch(Triple.getEnvironment()) {
512 case llvm::Triple::GNUEABI:
Daniel Dunbar2030d8f2009-09-14 00:34:46 +0000513 ABIName = "aapcs-linux";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000514 break;
515 case llvm::Triple::EABI:
Rafael Espindola1ed1a592010-06-16 19:01:17 +0000516 ABIName = "aapcs";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000517 break;
518 default:
Rafael Espindola1ed1a592010-06-16 19:01:17 +0000519 ABIName = "apcs-gnu";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000520 }
Daniel Dunbar2030d8f2009-09-14 00:34:46 +0000521 }
522 CmdArgs.push_back("-target-abi");
523 CmdArgs.push_back(ABIName);
524
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000525 // Set the CPU based on -march= and -mcpu=.
Daniel Dunbar38b48af2009-12-18 06:30:12 +0000526 CmdArgs.push_back("-target-cpu");
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000527 CmdArgs.push_back(getARMTargetCPU(Args, Triple));
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000528
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000529 // Select the float ABI as determined by -msoft-float, -mhard-float, and
530 // -mfloat-abi=.
531 llvm::StringRef FloatABI;
532 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
533 options::OPT_mhard_float,
534 options::OPT_mfloat_abi_EQ)) {
535 if (A->getOption().matches(options::OPT_msoft_float))
536 FloatABI = "soft";
537 else if (A->getOption().matches(options::OPT_mhard_float))
538 FloatABI = "hard";
539 else {
540 FloatABI = A->getValue(Args);
541 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
542 D.Diag(clang::diag::err_drv_invalid_mfloat_abi)
543 << A->getAsString(Args);
544 FloatABI = "soft";
545 }
546 }
547 }
548
549 // If unspecified, choose the default based on the platform.
550 if (FloatABI.empty()) {
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000551 const llvm::Triple &Triple = getToolChain().getTriple();
552 switch (Triple.getOS()) {
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000553 case llvm::Triple::Darwin: {
554 // Darwin defaults to "softfp" for v6 and v7.
555 //
556 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000557 llvm::StringRef ArchName =
558 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000559 if (ArchName.startswith("v6") || ArchName.startswith("v7"))
560 FloatABI = "softfp";
561 else
562 FloatABI = "soft";
563 break;
564 }
565
Rafael Espindola7e9cebf2010-06-27 18:29:21 +0000566 case llvm::Triple::Linux: {
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000567 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) {
Rafael Espindola7e9cebf2010-06-27 18:29:21 +0000568 FloatABI = "softfp";
569 break;
570 }
571 }
572 // fall through
573
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000574 default:
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000575 switch(Triple.getEnvironment()) {
576 case llvm::Triple::GNUEABI:
577 FloatABI = "softfp";
578 break;
579 case llvm::Triple::EABI:
580 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
581 FloatABI = "softfp";
582 break;
583 default:
584 // Assume "soft", but warn the user we are guessing.
585 FloatABI = "soft";
586 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
587 break;
588 }
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000589 }
590 }
591
592 if (FloatABI == "soft") {
593 // Floating point operations and argument passing are soft.
594 //
595 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbar3b315262009-11-30 08:42:00 +0000596 CmdArgs.push_back("-msoft-float");
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000597 CmdArgs.push_back("-mfloat-abi");
598 CmdArgs.push_back("soft");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000599 } else if (FloatABI == "softfp") {
600 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000601 CmdArgs.push_back("-mfloat-abi");
602 CmdArgs.push_back("soft");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000603 } else {
604 // Floating point operations and argument passing are hard.
605 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000606 CmdArgs.push_back("-mfloat-abi");
607 CmdArgs.push_back("hard");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000608 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +0000609
610 // Set appropriate target features for floating point mode.
611 //
612 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
613 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
614 // stripped out by the ARM target.
615
616 // Use software floating point operations?
617 if (FloatABI == "soft") {
618 CmdArgs.push_back("-target-feature");
619 CmdArgs.push_back("+soft-float");
620 }
621
622 // Use software floating point argument passing?
623 if (FloatABI != "hard") {
624 CmdArgs.push_back("-target-feature");
625 CmdArgs.push_back("+soft-float-abi");
626 }
Daniel Dunbara91320b2009-12-21 23:28:17 +0000627
628 // Honor -mfpu=.
629 //
630 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
631 // frontend target.
632 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
633 llvm::StringRef FPU = A->getValue(Args);
634
635 // Set the target features based on the FPU.
636 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
637 // Disable any default FPU support.
638 CmdArgs.push_back("-target-feature");
639 CmdArgs.push_back("-vfp2");
640 CmdArgs.push_back("-target-feature");
641 CmdArgs.push_back("-vfp3");
642 CmdArgs.push_back("-target-feature");
643 CmdArgs.push_back("-neon");
644 } else if (FPU == "vfp") {
645 CmdArgs.push_back("-target-feature");
646 CmdArgs.push_back("+vfp2");
647 } else if (FPU == "vfp3") {
648 CmdArgs.push_back("-target-feature");
649 CmdArgs.push_back("+vfp3");
650 } else if (FPU == "neon") {
651 CmdArgs.push_back("-target-feature");
652 CmdArgs.push_back("+neon");
653 } else
654 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
655 }
Daniel Dunbar7187fac2011-03-17 00:07:34 +0000656
657 // Setting -msoft-float effectively disables NEON because of the GCC
658 // implementation, although the same isn't true of VFP or VFP3.
659 if (FloatABI == "soft") {
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000660 CmdArgs.push_back("-target-feature");
661 CmdArgs.push_back("-neon");
662 }
663
664 // Kernel code has more strict alignment requirements.
665 if (KernelOrKext) {
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000666 CmdArgs.push_back("-backend-option");
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000667 CmdArgs.push_back("-arm-long-calls");
668
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000669 CmdArgs.push_back("-backend-option");
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000670 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbarb5fbb892011-04-18 21:26:42 +0000671
672 // The kext linker doesn't know how to deal with movw/movt.
673#ifndef DISABLE_ARM_DARWIN_USE_MOVT
674 CmdArgs.push_back("-backend-option");
675 CmdArgs.push_back("-arm-darwin-use-movt=0");
676#endif
Daniel Dunbar7187fac2011-03-17 00:07:34 +0000677 }
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000678}
679
Eric Christophered734732010-03-02 02:41:08 +0000680void Clang::AddMIPSTargetArgs(const ArgList &Args,
681 ArgStringList &CmdArgs) const {
682 const Driver &D = getToolChain().getDriver();
683
684 // Select the ABI to use.
685 const char *ABIName = 0;
686 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
687 ABIName = A->getValue(Args);
688 } else {
689 ABIName = "o32";
690 }
691
692 CmdArgs.push_back("-target-abi");
693 CmdArgs.push_back(ABIName);
694
695 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Nick Lewycky574bb5a2011-05-04 03:44:01 +0000696 llvm::StringRef MArch = A->getValue(Args);
Eric Christophered734732010-03-02 02:41:08 +0000697 CmdArgs.push_back("-target-cpu");
698
699 if ((MArch == "r2000") || (MArch == "r3000"))
700 CmdArgs.push_back("mips1");
701 else if (MArch == "r6000")
702 CmdArgs.push_back("mips2");
703 else
Nick Lewycky574bb5a2011-05-04 03:44:01 +0000704 CmdArgs.push_back(Args.MakeArgString(MArch));
Eric Christophered734732010-03-02 02:41:08 +0000705 }
706
707 // Select the float ABI as determined by -msoft-float, -mhard-float, and
708 llvm::StringRef FloatABI;
709 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
710 options::OPT_mhard_float)) {
711 if (A->getOption().matches(options::OPT_msoft_float))
712 FloatABI = "soft";
713 else if (A->getOption().matches(options::OPT_mhard_float))
714 FloatABI = "hard";
715 }
716
717 // If unspecified, choose the default based on the platform.
718 if (FloatABI.empty()) {
Benjamin Kramer71c972a2010-04-08 15:44:22 +0000719 // Assume "soft", but warn the user we are guessing.
720 FloatABI = "soft";
721 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Eric Christophered734732010-03-02 02:41:08 +0000722 }
723
724 if (FloatABI == "soft") {
725 // Floating point operations and argument passing are soft.
726 //
727 // FIXME: This changes CPP defines, we need -target-soft-float.
728 CmdArgs.push_back("-msoft-float");
729 } else {
730 assert(FloatABI == "hard" && "Invalid float abi!");
731 CmdArgs.push_back("-mhard-float");
732 }
733}
734
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +0000735void Clang::AddSparcTargetArgs(const ArgList &Args,
736 ArgStringList &CmdArgs) const {
737 const Driver &D = getToolChain().getDriver();
738
739 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
740 llvm::StringRef MArch = A->getValue(Args);
741 CmdArgs.push_back("-target-cpu");
742 CmdArgs.push_back(MArch.str().c_str());
743 }
744
745 // Select the float ABI as determined by -msoft-float, -mhard-float, and
746 llvm::StringRef FloatABI;
747 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
748 options::OPT_mhard_float)) {
749 if (A->getOption().matches(options::OPT_msoft_float))
750 FloatABI = "soft";
751 else if (A->getOption().matches(options::OPT_mhard_float))
752 FloatABI = "hard";
753 }
754
755 // If unspecified, choose the default based on the platform.
756 if (FloatABI.empty()) {
757 switch (getToolChain().getTriple().getOS()) {
758 default:
759 // Assume "soft", but warn the user we are guessing.
760 FloatABI = "soft";
761 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
762 break;
763 }
764 }
765
766 if (FloatABI == "soft") {
767 // Floating point operations and argument passing are soft.
768 //
769 // FIXME: This changes CPP defines, we need -target-soft-float.
770 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +0000771 CmdArgs.push_back("-target-feature");
772 CmdArgs.push_back("+soft-float");
773 } else {
774 assert(FloatABI == "hard" && "Invalid float abi!");
775 CmdArgs.push_back("-mhard-float");
776 }
777}
778
Daniel Dunbar6acda162009-09-09 22:33:08 +0000779void Clang::AddX86TargetArgs(const ArgList &Args,
780 ArgStringList &CmdArgs) const {
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000781 if (!Args.hasFlag(options::OPT_mred_zone,
782 options::OPT_mno_red_zone,
783 true) ||
784 Args.hasArg(options::OPT_mkernel) ||
785 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar66861e02009-11-20 22:21:36 +0000786 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000787
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000788 if (Args.hasFlag(options::OPT_msoft_float,
789 options::OPT_mno_soft_float,
790 false))
Daniel Dunbar66861e02009-11-20 22:21:36 +0000791 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000792
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000793 const char *CPUName = 0;
Daniel Dunbar6acda162009-09-09 22:33:08 +0000794 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000795 if (llvm::StringRef(A->getValue(Args)) == "native") {
796 // FIXME: Reject attempts to use -march=native unless the target matches
797 // the host.
798 //
799 // FIXME: We should also incorporate the detected target features for use
800 // with -native.
801 std::string CPU = llvm::sys::getHostCPUName();
802 if (!CPU.empty())
803 CPUName = Args.MakeArgString(CPU);
804 } else
805 CPUName = A->getValue(Args);
806 }
Daniel Dunbar6acda162009-09-09 22:33:08 +0000807
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000808 // Select the default CPU if none was given (or detection failed).
809 if (!CPUName) {
Daniel Dunbar6acda162009-09-09 22:33:08 +0000810 // FIXME: Need target hooks.
Benjamin Kramerf22d1fd2010-01-30 15:01:47 +0000811 if (getToolChain().getOS().startswith("darwin")) {
Daniel Dunbar951733d2011-05-31 15:58:55 +0000812 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000813 CPUName = "core2";
Daniel Dunbar951733d2011-05-31 15:58:55 +0000814 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000815 CPUName = "yonah";
Chris Lattner86ed3a32010-04-11 19:29:39 +0000816 } else if (getToolChain().getOS().startswith("haiku")) {
Daniel Dunbar951733d2011-05-31 15:58:55 +0000817 if (getToolChain().getArch() == llvm::Triple::x86_64)
Chris Lattner86ed3a32010-04-11 19:29:39 +0000818 CPUName = "x86-64";
Daniel Dunbar951733d2011-05-31 15:58:55 +0000819 else if (getToolChain().getArch() == llvm::Triple::x86)
Chris Lattner86ed3a32010-04-11 19:29:39 +0000820 CPUName = "i586";
Daniel Dunbar95c04572010-08-01 23:13:54 +0000821 } else if (getToolChain().getOS().startswith("openbsd")) {
Daniel Dunbar951733d2011-05-31 15:58:55 +0000822 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbar95c04572010-08-01 23:13:54 +0000823 CPUName = "x86-64";
Daniel Dunbar951733d2011-05-31 15:58:55 +0000824 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar95c04572010-08-01 23:13:54 +0000825 CPUName = "i486";
Roman Divacky451f8ca2011-03-01 18:11:37 +0000826 } else if (getToolChain().getOS().startswith("freebsd")) {
Daniel Dunbar951733d2011-05-31 15:58:55 +0000827 if (getToolChain().getArch() == llvm::Triple::x86_64)
Roman Divacky451f8ca2011-03-01 18:11:37 +0000828 CPUName = "x86-64";
Daniel Dunbar951733d2011-05-31 15:58:55 +0000829 else if (getToolChain().getArch() == llvm::Triple::x86)
Roman Divacky451f8ca2011-03-01 18:11:37 +0000830 CPUName = "i486";
Benjamin Kramer8e50a962011-02-02 18:59:27 +0000831 } else if (getToolChain().getOS().startswith("netbsd")) {
Daniel Dunbar951733d2011-05-31 15:58:55 +0000832 if (getToolChain().getArch() == llvm::Triple::x86_64)
Benjamin Kramer8e50a962011-02-02 18:59:27 +0000833 CPUName = "x86-64";
Daniel Dunbar951733d2011-05-31 15:58:55 +0000834 else if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer8e50a962011-02-02 18:59:27 +0000835 CPUName = "i486";
Daniel Dunbar6acda162009-09-09 22:33:08 +0000836 } else {
Daniel Dunbar951733d2011-05-31 15:58:55 +0000837 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000838 CPUName = "x86-64";
Daniel Dunbar951733d2011-05-31 15:58:55 +0000839 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000840 CPUName = "pentium4";
Daniel Dunbar6acda162009-09-09 22:33:08 +0000841 }
842 }
843
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000844 if (CPUName) {
Daniel Dunbar38b48af2009-12-18 06:30:12 +0000845 CmdArgs.push_back("-target-cpu");
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000846 CmdArgs.push_back(CPUName);
847 }
848
Eli Friedmand18eeca2011-07-02 00:34:19 +0000849 // The required algorithm here is slightly strange: the options are applied
850 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
851 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
852 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
853 // former correctly, but not the latter; handle directly-overridden
854 // attributes here.
855 llvm::StringMap<unsigned> PrevFeature;
856 std::vector<const char*> Features;
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000857 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
858 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000859 llvm::StringRef Name = (*it)->getOption().getName();
860 (*it)->claim();
Daniel Dunbar6acda162009-09-09 22:33:08 +0000861
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000862 // Skip over "-m".
863 assert(Name.startswith("-m") && "Invalid feature name.");
864 Name = Name.substr(2);
Daniel Dunbar6acda162009-09-09 22:33:08 +0000865
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000866 bool IsNegative = Name.startswith("no-");
867 if (IsNegative)
868 Name = Name.substr(3);
Daniel Dunbar6acda162009-09-09 22:33:08 +0000869
Eli Friedmand18eeca2011-07-02 00:34:19 +0000870 unsigned& Prev = PrevFeature[Name];
871 if (Prev)
872 Features[Prev - 1] = 0;
873 Prev = Features.size() + 1;
874 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
875 }
876 for (unsigned i = 0; i < Features.size(); i++) {
877 if (Features[i]) {
878 CmdArgs.push_back("-target-feature");
879 CmdArgs.push_back(Features[i]);
880 }
Daniel Dunbar6acda162009-09-09 22:33:08 +0000881 }
882}
883
Anders Carlsson525544d2011-02-28 00:44:51 +0000884static bool
John McCalld71315c2011-06-22 00:53:57 +0000885shouldUseExceptionTablesForObjCExceptions(unsigned objcABIVersion,
Anders Carlsson525544d2011-02-28 00:44:51 +0000886 const llvm::Triple &Triple) {
887 // We use the zero-cost exception tables for Objective-C if the non-fragile
888 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
889 // later.
890
John McCalld71315c2011-06-22 00:53:57 +0000891 if (objcABIVersion >= 2)
Anders Carlsson525544d2011-02-28 00:44:51 +0000892 return true;
893
894 if (Triple.getOS() != llvm::Triple::Darwin)
895 return false;
896
Eric Christopheraa7333c2011-07-02 00:20:22 +0000897 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson525544d2011-02-28 00:44:51 +0000898 (Triple.getArch() == llvm::Triple::x86_64 ||
899 Triple.getArch() == llvm::Triple::arm));
900}
901
Anders Carlsson15348ae2011-02-28 02:27:16 +0000902/// addExceptionArgs - Adds exception related arguments to the driver command
903/// arguments. There's a master flag, -fexceptions and also language specific
904/// flags to enable/disable C++ and Objective-C exceptions.
905/// This makes it possible to for example disable C++ exceptions but enable
906/// Objective-C exceptions.
907static void addExceptionArgs(const ArgList &Args, types::ID InputType,
908 const llvm::Triple &Triple,
909 bool KernelOrKext, bool IsRewriter,
John McCalld71315c2011-06-22 00:53:57 +0000910 unsigned objcABIVersion,
Anders Carlsson15348ae2011-02-28 02:27:16 +0000911 ArgStringList &CmdArgs) {
912 if (KernelOrKext)
913 return;
914
915 // Exceptions are enabled by default.
916 bool ExceptionsEnabled = true;
917
918 // This keeps track of whether exceptions were explicitly turned on or off.
919 bool DidHaveExplicitExceptionFlag = false;
920
Rafael Espindolaf759df02009-10-01 13:33:33 +0000921 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
922 options::OPT_fno_exceptions)) {
923 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlsson15348ae2011-02-28 02:27:16 +0000924 ExceptionsEnabled = true;
925 else
926 ExceptionsEnabled = false;
927
928 DidHaveExplicitExceptionFlag = true;
Rafael Espindolaf759df02009-10-01 13:33:33 +0000929 }
Daniel Dunbar1a2cd4f2010-09-14 23:12:31 +0000930
Anders Carlsson15348ae2011-02-28 02:27:16 +0000931 bool ShouldUseExceptionTables = false;
Fariborz Jahanian85caf032009-10-01 20:30:46 +0000932
Anders Carlsson15348ae2011-02-28 02:27:16 +0000933 // Exception tables and cleanups can be enabled with -fexceptions even if the
934 // language itself doesn't support exceptions.
935 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
936 ShouldUseExceptionTables = true;
Daniel Dunbar1a2cd4f2010-09-14 23:12:31 +0000937
Daniel Dunbard47ea692011-03-17 23:28:31 +0000938 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
939 // is not necessarily sensible, but follows GCC.
940 if (types::isObjC(InputType) &&
941 Args.hasFlag(options::OPT_fobjc_exceptions,
942 options::OPT_fno_objc_exceptions,
943 true)) {
944 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlsson15348ae2011-02-28 02:27:16 +0000945
Daniel Dunbard47ea692011-03-17 23:28:31 +0000946 ShouldUseExceptionTables |=
John McCalld71315c2011-06-22 00:53:57 +0000947 shouldUseExceptionTablesForObjCExceptions(objcABIVersion, Triple);
Anders Carlsson15348ae2011-02-28 02:27:16 +0000948 }
949
950 if (types::isCXX(InputType)) {
951 bool CXXExceptionsEnabled = ExceptionsEnabled;
952
953 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
954 options::OPT_fno_cxx_exceptions,
955 options::OPT_fexceptions,
956 options::OPT_fno_exceptions)) {
957 if (A->getOption().matches(options::OPT_fcxx_exceptions))
958 CXXExceptionsEnabled = true;
Chandler Carruth43f220f2011-02-28 07:25:18 +0000959 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlsson15348ae2011-02-28 02:27:16 +0000960 CXXExceptionsEnabled = false;
961 }
962
963 if (CXXExceptionsEnabled) {
964 CmdArgs.push_back("-fcxx-exceptions");
965
966 ShouldUseExceptionTables = true;
967 }
968 }
969
970 if (ShouldUseExceptionTables)
971 CmdArgs.push_back("-fexceptions");
Rafael Espindolaf759df02009-10-01 13:33:33 +0000972}
973
Rafael Espindola61b1efe2011-05-02 17:43:32 +0000974static bool ShouldDisableCFI(const ArgList &Args,
975 const ToolChain &TC) {
Rafael Espindola97f6abb2011-05-17 16:26:17 +0000976 if (TC.getTriple().getOS() == llvm::Triple::Darwin) {
977 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindolacb773922011-05-17 19:06:58 +0000978 // we disable them if we think the .s file will be passed to it.
Rafael Espindola61b1efe2011-05-02 17:43:32 +0000979
Rafael Espindola97f6abb2011-05-17 16:26:17 +0000980 // FIXME: Duplicated code with ToolChains.cpp
981 // FIXME: This doesn't belong here, but ideally we will support static soon
982 // anyway.
983 bool HasStatic = (Args.hasArg(options::OPT_mkernel) ||
984 Args.hasArg(options::OPT_static) ||
985 Args.hasArg(options::OPT_fapple_kext));
986 bool IsIADefault = TC.IsIntegratedAssemblerDefault() && !HasStatic;
987 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
988 options::OPT_no_integrated_as,
989 IsIADefault);
990 bool UseCFI = Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
991 options::OPT_fno_dwarf2_cfi_asm,
992 UseIntegratedAs);
993 return !UseCFI;
994 }
995
996 // For now we assume that every other assembler support CFI.
997 return false;
Rafael Espindola61b1efe2011-05-02 17:43:32 +0000998}
999
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00001000/// \brief Check whether the given input tree contains any compilation actions.
1001static bool ContainsCompileAction(const Action *A) {
Chris Lattner95946752011-07-20 06:37:11 +00001002 if (llvm::isa<CompileJobAction>(A))
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00001003 return true;
1004
1005 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1006 if (ContainsCompileAction(*it))
1007 return true;
1008
1009 return false;
1010}
1011
1012/// \brief Check if -relax-all should be passed to the internal assembler.
1013/// This is done by default when compiling non-assembler source with -O0.
1014static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1015 bool RelaxDefault = true;
1016
1017 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1018 RelaxDefault = A->getOption().matches(options::OPT_O0);
1019
1020 if (RelaxDefault) {
1021 RelaxDefault = false;
1022 for (ActionList::const_iterator it = C.getActions().begin(),
1023 ie = C.getActions().end(); it != ie; ++it) {
1024 if (ContainsCompileAction(*it)) {
1025 RelaxDefault = true;
1026 break;
1027 }
1028 }
1029 }
1030
1031 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1032 RelaxDefault);
1033}
1034
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00001035void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar871adcf2009-03-18 07:06:02 +00001036 const InputInfo &Output,
Daniel Dunbar62cf6012009-03-18 06:07:59 +00001037 const InputInfoList &Inputs,
Daniel Dunbar1d460332009-03-18 10:01:51 +00001038 const ArgList &Args,
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00001039 const char *LinkingOutput) const {
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001040 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1041 options::OPT_fapple_kext);
Daniel Dunbaree788e72009-12-21 18:54:17 +00001042 const Driver &D = getToolChain().getDriver();
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001043 ArgStringList CmdArgs;
1044
Daniel Dunbar077ba6a2009-03-31 20:53:55 +00001045 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1046
Daniel Dunbar8ff5b282009-12-11 23:00:49 +00001047 // Invoke ourselves in -cc1 mode.
1048 //
1049 // FIXME: Implement custom jobs for internal actions.
1050 CmdArgs.push_back("-cc1");
1051
Daniel Dunbardd4fe002009-10-30 18:12:20 +00001052 // Add the "effective" target triple.
Daniel Dunbaraf07f932009-03-31 17:35:15 +00001053 CmdArgs.push_back("-triple");
Daniel Dunbar00577ad2010-08-23 22:35:37 +00001054 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbardd4fe002009-10-30 18:12:20 +00001055 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbar728a5122009-09-10 06:49:20 +00001056
Daniel Dunbardd4fe002009-10-30 18:12:20 +00001057 // Select the appropriate action.
Daniel Dunbar5314e442010-07-19 19:44:22 +00001058 bool IsRewriter = false;
Daniel Dunbar1d460332009-03-18 10:01:51 +00001059 if (isa<AnalyzeJobAction>(JA)) {
1060 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1061 CmdArgs.push_back("-analyze");
1062 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +00001063 if (Output.getType() == types::TY_Dependencies)
1064 CmdArgs.push_back("-Eonly");
1065 else
1066 CmdArgs.push_back("-E");
Daniel Dunbar8767cbc2010-02-03 03:07:56 +00001067 } else if (isa<AssembleJobAction>(JA)) {
1068 CmdArgs.push_back("-emit-obj");
Daniel Dunbar99298002010-05-27 06:18:05 +00001069
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00001070 if (UseRelaxAll(C, Args))
Daniel Dunbar99298002010-05-27 06:18:05 +00001071 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarca0e0542010-08-24 16:47:49 +00001072
Daniel Dunbarfcec10b2010-10-18 22:36:15 +00001073 // When using an integrated assembler, translate -Wa, and -Xassembler
1074 // options.
1075 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1076 options::OPT_Xassembler),
1077 ie = Args.filtered_end(); it != ie; ++it) {
1078 const Arg *A = *it;
1079 A->claim();
1080
1081 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1082 llvm::StringRef Value = A->getValue(Args, i);
1083
1084 if (Value == "-force_cpusubtype_ALL") {
1085 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbarb14eed02010-10-28 20:36:23 +00001086 } else if (Value == "-L") {
Daniel Dunbar96932322011-03-28 22:49:28 +00001087 CmdArgs.push_back("-msave-temp-labels");
Joerg Sonnenberger46a49392011-05-19 20:46:39 +00001088 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergerd7933502011-05-19 18:42:29 +00001089 CmdArgs.push_back("-mllvm");
1090 CmdArgs.push_back("-fatal-assembler-warnings");
Nick Lewyckyc3b90142011-06-21 00:14:18 +00001091 } else if (Value == "--noexecstack") {
1092 CmdArgs.push_back("-mnoexecstack");
Daniel Dunbarfcec10b2010-10-18 22:36:15 +00001093 } else {
1094 D.Diag(clang::diag::err_drv_unsupported_option_argument)
1095 << A->getOption().getName() << Value;
1096 }
1097 }
1098 }
Daniel Dunbard02bba82010-11-19 16:23:35 +00001099
1100 // Also ignore explicit -force_cpusubtype_ALL option.
1101 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001102 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidise5c35372010-08-11 23:27:58 +00001103 // Use PCH if the user requested it.
Daniel Dunbar0ebd9322009-10-15 20:02:44 +00001104 bool UsePCH = D.CCCUsePCH;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +00001105
1106 if (UsePCH)
Douglas Gregordf91ef32009-04-18 00:34:01 +00001107 CmdArgs.push_back("-emit-pch");
1108 else
1109 CmdArgs.push_back("-emit-pth");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001110 } else {
1111 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001112
Daniel Dunbar1d460332009-03-18 10:01:51 +00001113 if (JA.getType() == types::TY_Nothing) {
1114 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00001115 } else if (JA.getType() == types::TY_LLVM_IR ||
1116 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00001117 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00001118 } else if (JA.getType() == types::TY_LLVM_BC ||
1119 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00001120 CmdArgs.push_back("-emit-llvm-bc");
1121 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbare3b8d072009-09-17 00:47:53 +00001122 CmdArgs.push_back("-S");
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00001123 } else if (JA.getType() == types::TY_AST) {
1124 CmdArgs.push_back("-emit-pch");
Daniel Dunbar64952502010-02-11 03:16:21 +00001125 } else if (JA.getType() == types::TY_RewrittenObjC) {
1126 CmdArgs.push_back("-rewrite-objc");
Daniel Dunbar5314e442010-07-19 19:44:22 +00001127 IsRewriter = true;
Daniel Dunbar64952502010-02-11 03:16:21 +00001128 } else {
1129 assert(JA.getType() == types::TY_PP_Asm &&
1130 "Unexpected output type!");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001131 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001132 }
1133
Daniel Dunbar1d460332009-03-18 10:01:51 +00001134 // The make clang go fast button.
1135 CmdArgs.push_back("-disable-free");
1136
John McCallb689afb2010-02-13 03:50:24 +00001137 // Disable the verification pass in -asserts builds.
1138#ifdef NDEBUG
1139 CmdArgs.push_back("-disable-llvm-verifier");
1140#endif
1141
Daniel Dunbarc9abc042009-04-08 05:11:16 +00001142 // Set the main file name, so that debug info works even with
1143 // -save-temps.
1144 CmdArgs.push_back("-main-file-name");
1145 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
1146
Daniel Dunbar3bbc7532009-04-08 18:03:55 +00001147 // Some flags which affect the language (via preprocessor
1148 // defines). See darwin::CC1::AddCPPArgs.
1149 if (Args.hasArg(options::OPT_static))
1150 CmdArgs.push_back("-static-define");
1151
Daniel Dunbar1d460332009-03-18 10:01:51 +00001152 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenekb8bb3e72009-09-25 05:55:59 +00001153 // Enable region store model by default.
1154 CmdArgs.push_back("-analyzer-store=region");
1155
Ted Kremenekb40d06d2009-12-07 22:26:14 +00001156 // Treat blocks as analysis entry points.
1157 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1158
Ted Kremenek51885072011-03-24 00:28:47 +00001159 CmdArgs.push_back("-analyzer-eagerly-assume");
1160
Daniel Dunbar1d460332009-03-18 10:01:51 +00001161 // Add default argument set.
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00001162 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00001163 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek51885072011-03-24 00:28:47 +00001164 CmdArgs.push_back("-analyzer-checker=deadcode");
1165 CmdArgs.push_back("-analyzer-checker=security");
1166
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00001167 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1168 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek51885072011-03-24 00:28:47 +00001169
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00001170 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek51885072011-03-24 00:28:47 +00001171 CmdArgs.push_back("-analyzer-checker=osx");
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00001172 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001173
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00001174 // Set the output format. The default is plist, for (lame) historical
1175 // reasons.
1176 CmdArgs.push_back("-analyzer-output");
1177 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
1178 CmdArgs.push_back(A->getValue(Args));
1179 else
1180 CmdArgs.push_back("plist");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001181
Ted Kremenek0647a7b2010-03-22 22:32:05 +00001182 // Disable the presentation of standard compiler warnings when
1183 // using --analyze. We only want to show static analyzer diagnostics
1184 // or frontend errors.
1185 CmdArgs.push_back("-w");
1186
Daniel Dunbar1d460332009-03-18 10:01:51 +00001187 // Add -Xanalyzer arguments when running as analyzer.
1188 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump1eb44332009-09-09 15:08:12 +00001189 }
1190
Daniel Dunbare2fd6642009-09-10 01:21:12 +00001191 CheckCodeGenerationOptions(D, Args);
1192
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001193 // Perform argument translation for LLVM backend. This
1194 // takes some care in reconciling with llvm-gcc. The
1195 // issue is that llvm-gcc translates these options based on
1196 // the values in cc1, whereas we are processing based on
1197 // the driver arguments.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001198
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001199 // This comes from the default translation the driver + cc1
1200 // would do to enable flag_pic.
1201 //
1202 // FIXME: Centralize this code.
1203 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
1204 Args.hasArg(options::OPT_fpic) ||
1205 Args.hasArg(options::OPT_fPIE) ||
1206 Args.hasArg(options::OPT_fpie));
1207 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
1208 Args.hasArg(options::OPT_static));
1209 const char *Model = getToolChain().GetForcedPicModel();
1210 if (!Model) {
1211 if (Args.hasArg(options::OPT_mdynamic_no_pic))
1212 Model = "dynamic-no-pic";
1213 else if (PICDisabled)
1214 Model = "static";
1215 else if (PICEnabled)
1216 Model = "pic";
Daniel Dunbar1d460332009-03-18 10:01:51 +00001217 else
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001218 Model = getToolChain().GetDefaultRelocationModel();
Daniel Dunbar1d460332009-03-18 10:01:51 +00001219 }
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001220 if (llvm::StringRef(Model) != "pic") {
1221 CmdArgs.push_back("-mrelocation-model");
1222 CmdArgs.push_back(Model);
1223 }
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001224
1225 // Infer the __PIC__ value.
1226 //
1227 // FIXME: This isn't quite right on Darwin, which always sets
1228 // __PIC__=2.
1229 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
Daniel Dunbar76743522009-11-29 02:39:08 +00001230 CmdArgs.push_back("-pic-level");
1231 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001232 }
Tanya Lattner59876c22009-11-04 01:18:09 +00001233 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1234 options::OPT_fno_merge_all_constants))
Chris Lattnerf44a1a02011-04-08 18:06:54 +00001235 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00001236
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001237 // LLVM Code Generator Options.
1238
Daniel Dunbar17d3fea2011-02-09 17:54:19 +00001239 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1240 CmdArgs.push_back("-mregparm");
1241 CmdArgs.push_back(A->getValue(Args));
1242 }
1243
Roman Divackycfe9af22011-03-01 17:40:53 +00001244 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1245 CmdArgs.push_back("-mrtd");
1246
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001247 // FIXME: Set --enable-unsafe-fp-math.
1248 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
1249 options::OPT_fomit_frame_pointer))
1250 CmdArgs.push_back("-mdisable-fp-elim");
1251 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1252 options::OPT_fno_zero_initialized_in_bss))
1253 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Daniel Dunbar398c6102011-02-04 02:20:39 +00001254 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1255 options::OPT_fno_strict_aliasing,
1256 getToolChain().IsStrictAliasingDefault()))
Dan Gohman4d5625e2010-10-14 22:36:56 +00001257 CmdArgs.push_back("-relaxed-aliasing");
Daniel Dunbar1b718482010-05-14 22:00:22 +00001258
1259 // Decide whether to use verbose asm. Verbose assembly is the default on
1260 // toolchains which have the integrated assembler on by default.
1261 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
1262 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer20249a12010-10-21 03:16:25 +00001263 IsVerboseAsmDefault) ||
Daniel Dunbar1b718482010-05-14 22:00:22 +00001264 Args.hasArg(options::OPT_dA))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001265 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar1b718482010-05-14 22:00:22 +00001266
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001267 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
1268 CmdArgs.push_back("-mdebug-pass");
1269 CmdArgs.push_back("Structure");
1270 }
1271 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
1272 CmdArgs.push_back("-mdebug-pass");
1273 CmdArgs.push_back("Arguments");
1274 }
1275
John McCalld0c2ec42010-02-19 02:45:38 +00001276 // Enable -mconstructor-aliases except on darwin, where we have to
1277 // work around a linker bug; see <rdar://problem/7651567>.
1278 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin)
1279 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00001280
John McCall32096692011-03-18 02:56:14 +00001281 // Darwin's kernel doesn't support guard variables; just die if we
1282 // try to use them.
1283 if (KernelOrKext &&
1284 getToolChain().getTriple().getOS() == llvm::Triple::Darwin)
1285 CmdArgs.push_back("-fforbid-guard-variables");
1286
Douglas Gregor6f755502011-02-01 15:15:22 +00001287 if (Args.hasArg(options::OPT_mms_bitfields)) {
1288 CmdArgs.push_back("-mms-bitfields");
1289 }
John McCalld0c2ec42010-02-19 02:45:38 +00001290
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00001291 // This is a coarse approximation of what llvm-gcc actually does, both
1292 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
1293 // complicated ways.
1294 bool AsynchronousUnwindTables =
1295 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
1296 options::OPT_fno_asynchronous_unwind_tables,
1297 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001298 !KernelOrKext);
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00001299 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
1300 AsynchronousUnwindTables))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001301 CmdArgs.push_back("-munwind-tables");
1302
1303 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
1304 CmdArgs.push_back("-mlimit-float-precision");
1305 CmdArgs.push_back(A->getValue(Args));
1306 }
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001307
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001308 // FIXME: Handle -mtune=.
1309 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001310
Benjamin Kramer8e9ef0d2009-08-05 14:30:52 +00001311 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001312 CmdArgs.push_back("-mcode-model");
Benjamin Kramer8e9ef0d2009-08-05 14:30:52 +00001313 CmdArgs.push_back(A->getValue(Args));
1314 }
1315
Daniel Dunbar6acda162009-09-09 22:33:08 +00001316 // Add target specific cpu and features flags.
1317 switch(getToolChain().getTriple().getArch()) {
1318 default:
1319 break;
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001320
Daniel Dunbarb163ef72009-09-10 04:57:17 +00001321 case llvm::Triple::arm:
1322 case llvm::Triple::thumb:
Daniel Dunbarfa41d692011-03-17 17:10:06 +00001323 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbarb163ef72009-09-10 04:57:17 +00001324 break;
1325
Eric Christophered734732010-03-02 02:41:08 +00001326 case llvm::Triple::mips:
1327 case llvm::Triple::mipsel:
1328 AddMIPSTargetArgs(Args, CmdArgs);
1329 break;
1330
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001331 case llvm::Triple::sparc:
1332 AddSparcTargetArgs(Args, CmdArgs);
1333 break;
1334
Daniel Dunbar6acda162009-09-09 22:33:08 +00001335 case llvm::Triple::x86:
1336 case llvm::Triple::x86_64:
1337 AddX86TargetArgs(Args, CmdArgs);
1338 break;
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001339 }
1340
Daniel Dunbarc176bc62010-08-11 23:07:47 +00001341 // Pass the linker version in use.
1342 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1343 CmdArgs.push_back("-target-linker-version");
1344 CmdArgs.push_back(A->getValue(Args));
1345 }
1346
Nick Lewyckyb2d11cc2011-02-02 06:43:03 +00001347 // -mno-omit-leaf-frame-pointer is the default on Darwin.
Daniel Dunbar1ad66482010-07-01 01:31:45 +00001348 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
Nick Lewyckyb2d11cc2011-02-02 06:43:03 +00001349 options::OPT_mno_omit_leaf_frame_pointer,
1350 getToolChain().getTriple().getOS() != llvm::Triple::Darwin))
Daniel Dunbar1ad66482010-07-01 01:31:45 +00001351 CmdArgs.push_back("-momit-leaf-frame-pointer");
1352
Dan Gohmanc31176d2010-01-08 02:20:44 +00001353 // -fno-math-errno is default.
1354 if (Args.hasFlag(options::OPT_fmath_errno,
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001355 options::OPT_fno_math_errno,
Dan Gohmanc31176d2010-01-08 02:20:44 +00001356 false))
1357 CmdArgs.push_back("-fmath-errno");
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001358
Daniel Dunbarb30575c2010-05-12 18:19:58 +00001359 // Explicitly error on some things we know we don't support and can't just
1360 // ignore.
1361 types::ID InputType = Inputs[0].getType();
Daniel Dunbare94db472010-09-24 19:39:37 +00001362 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1363 Arg *Unsupported;
Peter Collingbournebb527862011-07-12 19:35:15 +00001364 if ((Unsupported = Args.getLastArg(options::OPT_iframework)))
Daniel Dunbare94db472010-09-24 19:39:37 +00001365 D.Diag(clang::diag::err_drv_clang_unsupported)
Daniel Dunbarb30575c2010-05-12 18:19:58 +00001366 << Unsupported->getOption().getName();
Daniel Dunbare94db472010-09-24 19:39:37 +00001367
1368 if (types::isCXX(InputType) &&
1369 getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1370 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1371 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)))
1372 D.Diag(clang::diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1373 << Unsupported->getOption().getName();
1374 }
Daniel Dunbarb30575c2010-05-12 18:19:58 +00001375 }
1376
Daniel Dunbar1d460332009-03-18 10:01:51 +00001377 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbarf7c16d92010-08-24 22:44:13 +00001378 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierd7a3ba02011-07-20 21:16:17 +00001379 if (D.CCPrintHeaders) {
Daniel Dunbar322c29f2011-02-02 21:11:35 +00001380 CmdArgs.push_back("-header-include-file");
1381 CmdArgs.push_back(D.CCPrintHeadersFilename ?
1382 D.CCPrintHeadersFilename : "-");
1383 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00001384 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump1eb44332009-09-09 15:08:12 +00001385 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001386
Chad Rosierd7a3ba02011-07-20 21:16:17 +00001387 if (D.CCLogDiagnostics) {
Daniel Dunbarc8a22b02011-04-07 18:01:20 +00001388 CmdArgs.push_back("-diagnostic-log-file");
1389 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
1390 D.CCLogDiagnosticsFilename : "-");
1391 }
1392
Daniel Dunbar1d460332009-03-18 10:01:51 +00001393 // Special case debug options to only pass -g to clang. This is
1394 // wrong.
Rafael Espindola18f36d92010-03-07 04:46:18 +00001395 Args.ClaimAllArgs(options::OPT_g_Group);
Daniel Dunbar6b3d5a62010-05-12 18:19:55 +00001396 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
1397 if (!A->getOption().matches(options::OPT_g0))
1398 CmdArgs.push_back("-g");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001399
Rafael Espindola9cf933a2010-05-06 21:06:04 +00001400 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1401 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1402
Chris Lattner7255a2d2010-06-22 00:03:40 +00001403 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
1404
Nick Lewyckye8ba8d72011-04-21 23:44:07 +00001405 if (Args.hasArg(options::OPT_ftest_coverage) ||
1406 Args.hasArg(options::OPT_coverage))
1407 CmdArgs.push_back("-femit-coverage-notes");
1408 if (Args.hasArg(options::OPT_fprofile_arcs) ||
1409 Args.hasArg(options::OPT_coverage))
1410 CmdArgs.push_back("-femit-coverage-data");
1411
Nick Lewycky5ea4f442011-05-04 20:46:58 +00001412 if (C.getArgs().hasArg(options::OPT_c) ||
1413 C.getArgs().hasArg(options::OPT_S)) {
1414 if (Output.isFilename()) {
Nick Lewycky3dc05412011-05-05 00:08:20 +00001415 CmdArgs.push_back("-coverage-file");
1416 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
Nick Lewycky5ea4f442011-05-04 20:46:58 +00001417 }
1418 }
1419
Daniel Dunbar1d460332009-03-18 10:01:51 +00001420 Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
Douglas Gregor4c2bcad2010-03-24 20:13:48 +00001421 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
Rafael Espindola8d737cc2009-10-26 13:36:57 +00001422 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001423
Daniel Dunbar5f122322009-12-15 01:02:52 +00001424 // Pass the path to compiler resource files.
Daniel Dunbar5f122322009-12-15 01:02:52 +00001425 CmdArgs.push_back("-resource-dir");
Daniel Dunbar225c4172010-01-20 02:35:16 +00001426 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar2ac9fc22009-04-07 21:42:00 +00001427
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001428 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
1429
John McCall8f0e8d22011-06-15 23:25:17 +00001430 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
Argyrios Kyrtzidis72ac1202011-07-07 04:00:39 +00001431 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis69325d52011-07-09 20:00:58 +00001432 options::OPT_ccc_arcmt_modify,
1433 options::OPT_ccc_arcmt_migrate)) {
John McCall8f0e8d22011-06-15 23:25:17 +00001434 switch (A->getOption().getID()) {
1435 default:
1436 llvm_unreachable("missed a case");
Argyrios Kyrtzidis72ac1202011-07-07 04:00:39 +00001437 case options::OPT_ccc_arcmt_check:
John McCall8f0e8d22011-06-15 23:25:17 +00001438 CmdArgs.push_back("-arcmt-check");
1439 break;
Argyrios Kyrtzidis72ac1202011-07-07 04:00:39 +00001440 case options::OPT_ccc_arcmt_modify:
John McCall8f0e8d22011-06-15 23:25:17 +00001441 CmdArgs.push_back("-arcmt-modify");
1442 break;
Argyrios Kyrtzidis69325d52011-07-09 20:00:58 +00001443 case options::OPT_ccc_arcmt_migrate:
1444 CmdArgs.push_back("-arcmt-migrate");
1445 CmdArgs.push_back("-arcmt-migrate-directory");
1446 CmdArgs.push_back(A->getValue(Args));
Argyrios Kyrtzidis7ee20492011-07-19 17:20:03 +00001447
1448 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
1449 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis69325d52011-07-09 20:00:58 +00001450 break;
John McCall8f0e8d22011-06-15 23:25:17 +00001451 }
1452 }
1453 }
1454
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001455 // Add preprocessing options like -I, -D, etc. if we are using the
1456 // preprocessor.
1457 //
1458 // FIXME: Support -fpreprocessed
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001459 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Douglas Gregordf91ef32009-04-18 00:34:01 +00001460 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001461
Rafael Espindola19d9d2e2011-07-21 23:40:37 +00001462 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
1463 // that "The compiler can only warn and ignore the option if not recognized".
1464 // When building with ccache, it will pass -D options to clang even on
1465 // preprocessed inputs and configure concludes that -fPIC is not supported.
1466 Args.ClaimAllArgs(options::OPT_D);
1467
Daniel Dunbar20f0eac2009-09-17 06:53:36 +00001468 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar337a6272009-03-24 20:17:30 +00001469 // others.
1470 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbarb827a052009-11-19 03:26:40 +00001471 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar337a6272009-03-24 20:17:30 +00001472 CmdArgs.push_back("-O3");
Daniel Dunbar473916c2010-05-27 06:51:08 +00001473 else if (A->getOption().matches(options::OPT_O) &&
1474 A->getValue(Args)[0] == '\0')
Daniel Dunbar20f0eac2009-09-17 06:53:36 +00001475 CmdArgs.push_back("-O2");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001476 else
Daniel Dunbar5697aa02009-03-18 23:39:35 +00001477 A->render(Args, CmdArgs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001478 }
1479
Daniel Dunbar6e8371e2009-10-29 02:24:45 +00001480 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
1481 Args.AddLastArg(CmdArgs, options::OPT_pedantic);
1482 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001483 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbard573d262009-04-07 22:13:21 +00001484
1485 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
1486 // (-ansi is equivalent to -std=c89).
1487 //
1488 // If a std is supplied, only add -trigraphs if it follows the
1489 // option.
1490 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1491 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes528365d2009-10-16 14:28:06 +00001492 if (types::isCXX(InputType))
Daniel Dunbar294691e2009-11-04 06:24:38 +00001493 CmdArgs.push_back("-std=c++98");
Nuno Lopes528365d2009-10-16 14:28:06 +00001494 else
Daniel Dunbar294691e2009-11-04 06:24:38 +00001495 CmdArgs.push_back("-std=c89");
Daniel Dunbard573d262009-04-07 22:13:21 +00001496 else
1497 Std->render(Args, CmdArgs);
1498
Daniel Dunbar0e100312010-06-14 21:23:08 +00001499 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
1500 options::OPT_trigraphs))
1501 if (A != Std)
Daniel Dunbard573d262009-04-07 22:13:21 +00001502 A->render(Args, CmdArgs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00001503 } else {
1504 // Honor -std-default.
Daniel Dunbar4a5290e2010-01-29 21:03:02 +00001505 //
1506 // FIXME: Clang doesn't correctly handle -std= when the input language
1507 // doesn't match. For the time being just ignore this for C++ inputs;
1508 // eventually we want to do all the standard defaulting here instead of
1509 // splitting it between the driver and clang -cc1.
1510 if (!types::isCXX(InputType))
1511 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1512 "-std=", /*Joined=*/true);
Daniel Dunbard573d262009-04-07 22:13:21 +00001513 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00001514 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001515
Chandler Carruth50465d12011-04-23 06:30:43 +00001516 // Map the bizarre '-Wwrite-strings' flag to a more sensible
1517 // '-fconst-strings'; this better indicates its actual behavior.
1518 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
1519 false)) {
1520 // For perfect compatibility with GCC, we do this even in the presence of
1521 // '-w'. This flag names something other than a warning for GCC.
1522 CmdArgs.push_back("-fconst-strings");
1523 }
1524
Chandler Carruth1cfe3c32011-04-23 09:27:53 +00001525 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruthf8c247d2011-04-23 19:48:40 +00001526 // during C++ compilation, which it is by default. GCC keeps this define even
1527 // in the presence of '-w', match this behavior bug-for-bug.
1528 if (types::isCXX(InputType) &&
1529 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
1530 true)) {
1531 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth1cfe3c32011-04-23 09:27:53 +00001532 }
1533
Chandler Carruthc304ba32010-05-22 02:21:53 +00001534 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
1535 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
1536 if (Asm->getOption().matches(options::OPT_fasm))
1537 CmdArgs.push_back("-fgnu-keywords");
1538 else
1539 CmdArgs.push_back("-fno-gnu-keywords");
1540 }
1541
Rafael Espindola61b1efe2011-05-02 17:43:32 +00001542 if (ShouldDisableCFI(Args, getToolChain()))
1543 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolaf24a1512011-04-30 18:35:43 +00001544
Daniel Dunbar1d460332009-03-18 10:01:51 +00001545 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
1546 CmdArgs.push_back("-ftemplate-depth");
1547 CmdArgs.push_back(A->getValue(Args));
1548 }
1549
Argyrios Kyrtzidis1380a142010-11-18 00:20:36 +00001550 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
1551 options::OPT_Wlarge_by_value_copy_def)) {
1552 CmdArgs.push_back("-Wlarge-by-value-copy");
Argyrios Kyrtzidis3532fdd2010-11-17 23:11:54 +00001553 if (A->getNumValues())
1554 CmdArgs.push_back(A->getValue(Args));
1555 else
Argyrios Kyrtzidis1380a142010-11-18 00:20:36 +00001556 CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy.
Argyrios Kyrtzidis3532fdd2010-11-17 23:11:54 +00001557 }
1558
Daniel Dunbare4bdae72009-11-19 04:00:53 +00001559 if (Args.hasArg(options::OPT__relocatable_pch))
Daniel Dunbar66861e02009-11-20 22:21:36 +00001560 CmdArgs.push_back("-relocatable-pch");
Mike Stump1eb44332009-09-09 15:08:12 +00001561
Daniel Dunbar294691e2009-11-04 06:24:38 +00001562 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
1563 CmdArgs.push_back("-fconstant-string-class");
1564 CmdArgs.push_back(A->getValue(Args));
1565 }
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001566
Chris Lattner124fca52010-01-09 21:54:33 +00001567 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
1568 CmdArgs.push_back("-ftabstop");
1569 CmdArgs.push_back(A->getValue(Args));
1570 }
1571
Chris Lattner0f0c9632010-04-07 20:49:23 +00001572 CmdArgs.push_back("-ferror-limit");
1573 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
1574 CmdArgs.push_back(A->getValue(Args));
1575 else
1576 CmdArgs.push_back("19");
Douglas Gregor575cf372010-04-20 07:18:24 +00001577
Chandler Carruthc40f73c2010-05-06 04:55:18 +00001578 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
1579 CmdArgs.push_back("-fmacro-backtrace-limit");
Douglas Gregor6c1cb992010-05-04 17:13:42 +00001580 CmdArgs.push_back(A->getValue(Args));
Chandler Carruthc40f73c2010-05-06 04:55:18 +00001581 }
1582
1583 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
1584 CmdArgs.push_back("-ftemplate-backtrace-limit");
Douglas Gregor575cf372010-04-20 07:18:24 +00001585 CmdArgs.push_back(A->getValue(Args));
Chandler Carruthc40f73c2010-05-06 04:55:18 +00001586 }
1587
Daniel Dunbar55efe142009-11-04 06:24:47 +00001588 // Pass -fmessage-length=.
Daniel Dunbara28690e2009-11-30 08:40:54 +00001589 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar55efe142009-11-04 06:24:47 +00001590 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Daniel Dunbara28690e2009-11-30 08:40:54 +00001591 CmdArgs.push_back(A->getValue(Args));
Daniel Dunbar55efe142009-11-04 06:24:47 +00001592 } else {
1593 // If -fmessage-length=N was not specified, determine whether this is a
1594 // terminal and, if so, implicitly define -fmessage-length appropriately.
1595 unsigned N = llvm::sys::Process::StandardErrColumns();
Daniel Dunbar55efe142009-11-04 06:24:47 +00001596 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N)));
1597 }
1598
Daniel Dunbarba8d8612009-12-03 18:42:11 +00001599 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
1600 CmdArgs.push_back("-fvisibility");
1601 CmdArgs.push_back(A->getValue(Args));
1602 }
1603
Douglas Gregor7cf84d62010-06-15 17:05:35 +00001604 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001605
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001606 // -fhosted is default.
1607 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
1608 options::OPT_fhosted,
1609 false))
1610 CmdArgs.push_back("-ffreestanding");
1611
Daniel Dunbarba8d8612009-12-03 18:42:11 +00001612 // Forward -f (flag) options which we can pass directly.
Mike Stump9c276ae2009-12-12 01:27:46 +00001613 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001614 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001615 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patelc69e1cf2010-09-30 19:05:55 +00001616 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00001617 if (getToolChain().SupportsProfiling())
1618 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar8c6fa842010-03-16 16:57:46 +00001619
1620 // -flax-vector-conversions is default.
1621 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
1622 options::OPT_fno_lax_vector_conversions))
1623 CmdArgs.push_back("-fno-lax-vector-conversions");
1624
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001625 if (Args.getLastArg(options::OPT_fapple_kext))
1626 CmdArgs.push_back("-fapple-kext");
1627
Fariborz Jahanian34e65772009-05-22 20:17:16 +00001628 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner182e0922009-04-21 05:34:31 +00001629 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregor4786c152010-08-19 20:24:43 +00001630 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001631 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
1632 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnall7f18e672010-09-17 18:29:54 +00001633
1634 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
1635 CmdArgs.push_back("-ftrapv-handler");
1636 CmdArgs.push_back(A->getValue(Args));
1637 }
1638
Evan Cheng49af1f32011-04-08 21:37:45 +00001639 // Forward -ftrap_function= options to the backend.
1640 if (Arg *A = Args.getLastArg(options::OPT_ftrap_function_EQ)) {
1641 llvm::StringRef FuncName = A->getValue(Args);
1642 CmdArgs.push_back("-backend-option");
1643 CmdArgs.push_back(Args.MakeArgString("-trap-func=" + FuncName));
1644 }
1645
Chandler Carruth5adb5a82011-03-27 00:04:55 +00001646 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
1647 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
1648 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
1649 options::OPT_fno_wrapv)) {
1650 if (A->getOption().matches(options::OPT_fwrapv))
1651 CmdArgs.push_back("-fwrapv");
1652 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
1653 options::OPT_fno_strict_overflow)) {
1654 if (A->getOption().matches(options::OPT_fno_strict_overflow))
1655 CmdArgs.push_back("-fwrapv");
1656 }
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001657 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf84d4092010-08-07 23:08:14 +00001658 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001659
Daniel Dunbar5345c392009-09-03 04:54:28 +00001660 Args.AddLastArg(CmdArgs, options::OPT_pthread);
1661
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001662 // -stack-protector=0 is default.
1663 unsigned StackProtectorLevel = 0;
Bill Wendling45483f72009-06-28 07:36:13 +00001664 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
1665 options::OPT_fstack_protector_all,
1666 options::OPT_fstack_protector)) {
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001667 if (A->getOption().matches(options::OPT_fstack_protector))
1668 StackProtectorLevel = 1;
1669 else if (A->getOption().matches(options::OPT_fstack_protector_all))
1670 StackProtectorLevel = 2;
1671 } else
1672 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel();
1673 if (StackProtectorLevel) {
1674 CmdArgs.push_back("-stack-protector");
1675 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel)));
Bill Wendling45483f72009-06-28 07:36:13 +00001676 }
1677
Eric Christopher1a584022011-05-02 21:18:22 +00001678 // Translate -mstackrealign
1679 if (Args.hasArg(options::OPT_mstackrealign)) {
1680 CmdArgs.push_back("-backend-option");
1681 CmdArgs.push_back("-force-align-stack");
1682 }
1683
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001684 // Forward -f options with positive and negative forms; we translate
1685 // these by hand.
1686
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001687 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar2843c192011-02-04 17:24:47 +00001688 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001689 CmdArgs.push_back("-fapple-kext");
1690 if (!Args.hasArg(options::OPT_fbuiltin))
1691 CmdArgs.push_back("-fno-builtin");
1692 }
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001693 // -fbuiltin is default.
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001694 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar53e84842009-11-19 04:55:23 +00001695 CmdArgs.push_back("-fno-builtin");
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001696
Nuno Lopesfc284482009-12-16 16:59:22 +00001697 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1698 options::OPT_fno_assume_sane_operator_new))
1699 CmdArgs.push_back("-fno-assume-sane-operator-new");
1700
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001701 // -fblocks=0 is default.
1702 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnalle6533ff2011-02-28 17:11:43 +00001703 getToolChain().IsBlocksDefault()) ||
1704 (Args.hasArg(options::OPT_fgnu_runtime) &&
1705 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
1706 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001707 CmdArgs.push_back("-fblocks");
David Chisnall5e530af2009-11-17 19:33:30 +00001708 }
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001709
John McCall32579cf2010-04-09 19:12:06 +00001710 // -faccess-control is default.
John McCall7002f4c2010-04-09 19:03:51 +00001711 if (Args.hasFlag(options::OPT_fno_access_control,
1712 options::OPT_faccess_control,
John McCall32579cf2010-04-09 19:12:06 +00001713 false))
John McCall7002f4c2010-04-09 19:03:51 +00001714 CmdArgs.push_back("-fno-access-control");
John McCall3ddd6e02010-03-17 01:32:13 +00001715
Anders Carlssona4c24752010-11-21 00:09:52 +00001716 // -felide-constructors is the default.
1717 if (Args.hasFlag(options::OPT_fno_elide_constructors,
1718 options::OPT_felide_constructors,
1719 false))
1720 CmdArgs.push_back("-fno-elide-constructors");
1721
Daniel Dunbar0be42c42009-11-17 07:06:20 +00001722 // -frtti is default.
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001723 if (KernelOrKext ||
1724 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
Daniel Dunbar53e84842009-11-19 04:55:23 +00001725 CmdArgs.push_back("-fno-rtti");
Mike Stump738f8c22009-07-31 23:15:31 +00001726
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +00001727 // -fshort-enums=0 is default.
1728 // FIXME: Are there targers where -fshort-enums is on by default ?
1729 if (Args.hasFlag(options::OPT_fshort_enums,
1730 options::OPT_fno_short_enums, false))
1731 CmdArgs.push_back("-fshort-enums");
1732
Daniel Dunbar1f95e652009-11-17 06:37:03 +00001733 // -fsigned-char is default.
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00001734 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbar1f95e652009-11-17 06:37:03 +00001735 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar76743522009-11-29 02:39:08 +00001736 CmdArgs.push_back("-fno-signed-char");
Eli Friedman5a779732009-06-05 07:21:14 +00001737
Anders Carlssona508b7d2010-02-06 23:23:06 +00001738 // -fthreadsafe-static is default.
Michael J. Spencer20249a12010-10-21 03:16:25 +00001739 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssona508b7d2010-02-06 23:23:06 +00001740 options::OPT_fno_threadsafe_statics))
1741 CmdArgs.push_back("-fno-threadsafe-statics");
1742
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001743 // -fuse-cxa-atexit is default.
Anton Korobeynikovd0a57d52010-09-11 11:17:06 +00001744 if (KernelOrKext ||
1745 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
NAKAMURA Takumicd7a30b2010-10-10 01:53:03 +00001746 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00001747 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001748 CmdArgs.push_back("-fno-use-cxa-atexit");
1749
Daniel Dunbar0be42c42009-11-17 07:06:20 +00001750 // -fms-extensions=0 is default.
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00001751 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0be42c42009-11-17 07:06:20 +00001752 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1753 CmdArgs.push_back("-fms-extensions");
1754
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001755 // -fmsc-version=1300 is default.
1756 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1757 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
1758 Args.hasArg(options::OPT_fmsc_version)) {
1759 llvm::StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
1760 if (msc_ver.empty())
1761 CmdArgs.push_back("-fmsc-version=1300");
1762 else
1763 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
1764 }
1765
1766
Dawn Perchik400b6072010-09-02 23:59:25 +00001767 // -fborland-extensions=0 is default.
1768 if (Args.hasFlag(options::OPT_fborland_extensions,
1769 options::OPT_fno_borland_extensions, false))
1770 CmdArgs.push_back("-fborland-extensions");
1771
Francois Pichet8387e2a2011-04-22 22:18:13 +00001772 // -fno-delayed-template-parsing is default.
1773 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
1774 options::OPT_fno_delayed_template_parsing,
1775 false))
1776 CmdArgs.push_back("-fdelayed-template-parsing");
1777
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00001778 // -fgnu-keywords default varies depending on language; only pass if
1779 // specified.
1780 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbar40788d92010-04-24 17:56:39 +00001781 options::OPT_fno_gnu_keywords))
1782 A->render(Args, CmdArgs);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00001783
Rafael Espindola01ba8542011-06-02 17:30:53 +00001784 if (Args.hasFlag(options::OPT_fgnu89_inline,
1785 options::OPT_fno_gnu89_inline,
1786 false))
Rafael Espindolafb3f4aa2011-06-02 16:13:27 +00001787 CmdArgs.push_back("-fgnu89-inline");
1788
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001789 // -fobjc-nonfragile-abi=0 is default.
John McCall9f084a32011-07-06 00:26:06 +00001790 ObjCRuntime objCRuntime;
John McCalld71315c2011-06-22 00:53:57 +00001791 unsigned objcABIVersion = 0;
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001792 if (types::isObjC(InputType)) {
John McCall9f084a32011-07-06 00:26:06 +00001793 bool NeXTRuntimeIsDefault
1794 = (IsRewriter || getToolChain().getTriple().isOSDarwin());
1795 if (Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
John McCallf1443be2011-07-06 02:36:30 +00001796 NeXTRuntimeIsDefault)) {
John McCall9f084a32011-07-06 00:26:06 +00001797 objCRuntime.setKind(ObjCRuntime::NeXT);
John McCallf1443be2011-07-06 02:36:30 +00001798 } else {
1799 CmdArgs.push_back("-fgnu-runtime");
John McCall9f084a32011-07-06 00:26:06 +00001800 objCRuntime.setKind(ObjCRuntime::GNU);
John McCallf1443be2011-07-06 02:36:30 +00001801 }
John McCall9f084a32011-07-06 00:26:06 +00001802 getToolChain().configureObjCRuntime(objCRuntime);
1803 if (objCRuntime.HasARC)
1804 CmdArgs.push_back("-fobjc-runtime-has-arc");
1805 if (objCRuntime.HasWeak)
1806 CmdArgs.push_back("-fobjc-runtime-has-weak");
John McCall256a76e2011-07-06 01:22:26 +00001807 if (objCRuntime.HasTerminate)
1808 CmdArgs.push_back("-fobjc-runtime-has-terminate");
John McCall9f084a32011-07-06 00:26:06 +00001809
Daniel Dunbardea63132010-09-20 18:19:55 +00001810 // Compute the Objective-C ABI "version" to use. Version numbers are
1811 // slightly confusing for historical reasons:
1812 // 1 - Traditional "fragile" ABI
1813 // 2 - Non-fragile ABI, version 1
1814 // 3 - Non-fragile ABI, version 2
John McCalld71315c2011-06-22 00:53:57 +00001815 objcABIVersion = 1;
Daniel Dunbardea63132010-09-20 18:19:55 +00001816 // If -fobjc-abi-version= is present, use that to set the version.
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001817 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
1818 if (llvm::StringRef(A->getValue(Args)) == "1")
John McCalld71315c2011-06-22 00:53:57 +00001819 objcABIVersion = 1;
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001820 else if (llvm::StringRef(A->getValue(Args)) == "2")
John McCalld71315c2011-06-22 00:53:57 +00001821 objcABIVersion = 2;
Fariborz Jahanian5f81d8a2010-09-15 16:00:51 +00001822 else if (llvm::StringRef(A->getValue(Args)) == "3")
John McCalld71315c2011-06-22 00:53:57 +00001823 objcABIVersion = 3;
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001824 else
1825 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbardea63132010-09-20 18:19:55 +00001826 } else {
1827 // Otherwise, determine if we are using the non-fragile ABI.
1828 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
1829 options::OPT_fno_objc_nonfragile_abi,
1830 getToolChain().IsObjCNonFragileABIDefault())) {
1831 // Determine the non-fragile ABI version to use.
Daniel Dunbarde17ba72010-11-11 16:08:59 +00001832#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
1833 unsigned NonFragileABIVersion = 1;
1834#else
Daniel Dunbardea63132010-09-20 18:19:55 +00001835 unsigned NonFragileABIVersion = 2;
Daniel Dunbarde17ba72010-11-11 16:08:59 +00001836#endif
Daniel Dunbardea63132010-09-20 18:19:55 +00001837
1838 if (Arg *A = Args.getLastArg(
1839 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
1840 if (llvm::StringRef(A->getValue(Args)) == "1")
1841 NonFragileABIVersion = 1;
1842 else if (llvm::StringRef(A->getValue(Args)) == "2")
1843 NonFragileABIVersion = 2;
1844 else
1845 D.Diag(clang::diag::err_drv_clang_unsupported)
1846 << A->getAsString(Args);
1847 }
1848
John McCalld71315c2011-06-22 00:53:57 +00001849 objcABIVersion = 1 + NonFragileABIVersion;
Daniel Dunbardea63132010-09-20 18:19:55 +00001850 } else {
John McCalld71315c2011-06-22 00:53:57 +00001851 objcABIVersion = 1;
Daniel Dunbardea63132010-09-20 18:19:55 +00001852 }
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001853 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001854
John McCalld71315c2011-06-22 00:53:57 +00001855 if (objcABIVersion == 2 || objcABIVersion == 3) {
Fariborz Jahanian112c3302011-01-04 20:05:20 +00001856 CmdArgs.push_back("-fobjc-nonfragile-abi");
Daniel Dunbarf643b9b2010-04-24 17:56:46 +00001857
1858 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
1859 // legacy is the default.
1860 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
1861 options::OPT_fno_objc_legacy_dispatch,
1862 getToolChain().IsObjCLegacyDispatchDefault())) {
1863 if (getToolChain().UseObjCMixedDispatch())
1864 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
1865 else
1866 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
1867 }
Daniel Dunbar984eb862010-02-01 21:07:25 +00001868 }
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00001869
Ted Kremenek29516372011-04-28 19:26:03 +00001870 // FIXME: Don't expose -fobjc-default-synthesize-properties as a top-level
1871 // driver flag yet. This feature is still under active development
1872 // and shouldn't be exposed as a user visible feature (which may change).
1873 // Clang still supports this as a -cc1 option for development and testing.
1874#if 0
Ted Kremenekc32647d2010-12-23 21:35:43 +00001875 // -fobjc-default-synthesize-properties=0 is default.
1876 if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties,
1877 options::OPT_fno_objc_default_synthesize_properties,
1878 getToolChain().IsObjCDefaultSynthPropertiesDefault())) {
1879 CmdArgs.push_back("-fobjc-default-synthesize-properties");
1880 }
Ted Kremenek29516372011-04-28 19:26:03 +00001881#endif
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001882 }
1883
John McCall9f084a32011-07-06 00:26:06 +00001884 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
1885 // NOTE: This logic is duplicated in ToolChains.cpp.
1886 bool ARC = isObjCAutoRefCount(Args);
1887 if (ARC) {
1888 CmdArgs.push_back("-fobjc-arc");
1889
1890 // Allow the user to enable full exceptions code emission.
1891 // We define off for Objective-CC, on for Objective-C++.
1892 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
1893 options::OPT_fno_objc_arc_exceptions,
1894 /*default*/ types::isCXX(InputType)))
1895 CmdArgs.push_back("-fobjc-arc-exceptions");
1896 }
1897
1898 // -fobjc-infer-related-result-type is the default, except in the Objective-C
1899 // rewriter.
1900 if (IsRewriter)
1901 CmdArgs.push_back("-fno-objc-infer-related-result-type");
1902
1903 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
1904 // takes precedence.
1905 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
1906 if (!GCArg)
1907 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
1908 if (GCArg) {
1909 if (ARC) {
1910 D.Diag(clang::diag::err_drv_objc_gc_arr)
1911 << GCArg->getAsString(Args);
1912 } else if (getToolChain().SupportsObjCGC()) {
1913 GCArg->render(Args, CmdArgs);
1914 } else {
1915 // FIXME: We should move this to a hard error.
1916 D.Diag(clang::diag::warn_drv_objc_gc_unsupported)
1917 << GCArg->getAsString(Args);
1918 }
1919 }
1920
John McCalld71315c2011-06-22 00:53:57 +00001921 // Add exception args.
1922 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
1923 KernelOrKext, IsRewriter, objcABIVersion, CmdArgs);
1924
1925 if (getToolChain().UseSjLjExceptions())
1926 CmdArgs.push_back("-fsjlj-exceptions");
1927
1928 // C++ "sane" operator new.
Daniel Dunbar984eb862010-02-01 21:07:25 +00001929 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1930 options::OPT_fno_assume_sane_operator_new))
1931 CmdArgs.push_back("-fno-assume-sane-operator-new");
1932
Daniel Dunbarf35f14d2010-04-27 15:34:57 +00001933 // -fconstant-cfstrings is default, and may be subject to argument translation
1934 // on Darwin.
1935 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
1936 options::OPT_fno_constant_cfstrings) ||
1937 !Args.hasFlag(options::OPT_mconstant_cfstrings,
1938 options::OPT_mno_constant_cfstrings))
1939 CmdArgs.push_back("-fno-constant-cfstrings");
1940
John Thompsona6fda122009-11-05 20:14:16 +00001941 // -fshort-wchar default varies depending on platform; only
1942 // pass if specified.
Daniel Dunbar1744a352010-04-27 15:35:03 +00001943 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
1944 A->render(Args, CmdArgs);
John Thompsona6fda122009-11-05 20:14:16 +00001945
Daniel Dunbaree848a72009-10-29 02:39:57 +00001946 // -fno-pascal-strings is default, only pass non-default. If the tool chain
1947 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbar82d00682009-04-07 23:51:44 +00001948 //
1949 // FIXME: This is gross; that translation should be pulled from the
1950 // tool chain.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001951 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbar82d00682009-04-07 23:51:44 +00001952 options::OPT_fno_pascal_strings,
1953 false) ||
1954 Args.hasFlag(options::OPT_mpascal_strings,
1955 options::OPT_mno_pascal_strings,
1956 false))
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001957 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00001958
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001959 if (Args.hasArg(options::OPT_mkernel) ||
1960 Args.hasArg(options::OPT_fapple_kext)) {
1961 if (!Args.hasArg(options::OPT_fcommon))
1962 CmdArgs.push_back("-fno-common");
1963 }
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001964 // -fcommon is default, only pass non-default.
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001965 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001966 CmdArgs.push_back("-fno-common");
1967
Daniel Dunbar70d3c922009-04-15 02:37:43 +00001968 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar06205ca2010-10-15 22:30:42 +00001969 // -funsigned-bitfields.
Mike Stump1eb44332009-09-09 15:08:12 +00001970 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar70d3c922009-04-15 02:37:43 +00001971 options::OPT_funsigned_bitfields))
1972 D.Diag(clang::diag::warn_drv_clang_unsupported)
1973 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
1974
Daniel Dunbar06205ca2010-10-15 22:30:42 +00001975 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
1976 if (!Args.hasFlag(options::OPT_ffor_scope,
1977 options::OPT_fno_for_scope))
1978 D.Diag(clang::diag::err_drv_clang_unsupported)
1979 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
1980
Jeffrey Yasskin0ea22fd2010-06-08 04:56:20 +00001981 // -fcaret-diagnostics is default.
1982 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
1983 options::OPT_fno_caret_diagnostics, true))
1984 CmdArgs.push_back("-fno-caret-diagnostics");
1985
Daniel Dunbar49138fc2009-04-19 21:09:34 +00001986 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump1eb44332009-09-09 15:08:12 +00001987 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar49138fc2009-04-19 21:09:34 +00001988 options::OPT_fno_diagnostics_fixit_info))
1989 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Douglas Gregor7d2b8c12011-04-15 22:04:17 +00001990
1991 // Enable -fdiagnostics-show-name by default.
1992 if (Args.hasFlag(options::OPT_fdiagnostics_show_name,
1993 options::OPT_fno_diagnostics_show_name, false))
1994 CmdArgs.push_back("-fdiagnostics-show-name");
Daniel Dunbar49138fc2009-04-19 21:09:34 +00001995
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00001996 // Enable -fdiagnostics-show-option by default.
Mike Stump1eb44332009-09-09 15:08:12 +00001997 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00001998 options::OPT_fno_diagnostics_show_option))
1999 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar838be482009-11-04 06:24:57 +00002000
Chris Lattner6fbe8392010-05-04 21:55:25 +00002001 if (const Arg *A =
2002 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2003 CmdArgs.push_back("-fdiagnostics-show-category");
2004 CmdArgs.push_back(A->getValue(Args));
2005 }
Daniel Dunbarca0e0542010-08-24 16:47:49 +00002006
Douglas Gregorc9471b02011-05-21 17:07:29 +00002007 if (const Arg *A =
2008 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2009 CmdArgs.push_back("-fdiagnostics-format");
2010 CmdArgs.push_back(A->getValue(Args));
2011 }
2012
Chandler Carruthabaca7a2011-03-27 01:50:55 +00002013 if (Arg *A = Args.getLastArg(
2014 options::OPT_fdiagnostics_show_note_include_stack,
2015 options::OPT_fno_diagnostics_show_note_include_stack)) {
2016 if (A->getOption().matches(
2017 options::OPT_fdiagnostics_show_note_include_stack))
2018 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2019 else
2020 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2021 }
2022
Daniel Dunbar838be482009-11-04 06:24:57 +00002023 // Color diagnostics are the default, unless the terminal doesn't support
2024 // them.
2025 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidisf765d762010-09-23 12:56:06 +00002026 options::OPT_fno_color_diagnostics,
2027 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar838be482009-11-04 06:24:57 +00002028 CmdArgs.push_back("-fcolor-diagnostics");
2029
Daniel Dunbar75eb1d62009-06-08 21:13:54 +00002030 if (!Args.hasFlag(options::OPT_fshow_source_location,
2031 options::OPT_fno_show_source_location))
2032 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00002033
Douglas Gregorc9471b02011-05-21 17:07:29 +00002034 if (!Args.hasFlag(options::OPT_fshow_column,
2035 options::OPT_fno_show_column,
2036 true))
2037 CmdArgs.push_back("-fno-show-column");
2038
Douglas Gregora0068fc2010-07-09 17:35:33 +00002039 if (!Args.hasFlag(options::OPT_fspell_checking,
2040 options::OPT_fno_spell_checking))
2041 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarca0e0542010-08-24 16:47:49 +00002042
Daniel Dunbar25b26eb2010-10-18 22:49:46 +00002043
Daniel Dunbar16894392010-11-02 19:42:04 +00002044 // Silently ignore -fasm-blocks for now.
2045 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2046 false);
Daniel Dunbar25b26eb2010-10-18 22:49:46 +00002047
Jeffrey Yasskin5edbdcc2010-06-11 05:57:47 +00002048 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2049 A->render(Args, CmdArgs);
2050
Daniel Dunbar7695fba2009-04-19 21:20:32 +00002051 // -fdollars-in-identifiers default varies depending on platform and
2052 // language; only pass if specified.
Mike Stump1eb44332009-09-09 15:08:12 +00002053 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbar7695fba2009-04-19 21:20:32 +00002054 options::OPT_fno_dollars_in_identifiers)) {
2055 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar8663b182009-12-16 20:10:18 +00002056 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbar7695fba2009-04-19 21:20:32 +00002057 else
Daniel Dunbar8663b182009-12-16 20:10:18 +00002058 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbar7695fba2009-04-19 21:20:32 +00002059 }
2060
Daniel Dunbare027a4b2009-05-22 19:02:20 +00002061 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
2062 // practical purposes.
Mike Stump1eb44332009-09-09 15:08:12 +00002063 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbare027a4b2009-05-22 19:02:20 +00002064 options::OPT_fno_unit_at_a_time)) {
2065 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Edward O'Callaghanc3769102009-10-13 16:41:34 +00002066 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbare027a4b2009-05-22 19:02:20 +00002067 }
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00002068
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002069 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00002070 //
Daniel Dunbar8ff5b282009-12-11 23:00:49 +00002071 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00002072#if 0
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002073 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
2074 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2075 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
2076 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2077 CmdArgs.push_back("-fno-builtin-strcat");
2078 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2079 CmdArgs.push_back("-fno-builtin-strcpy");
2080 }
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00002081#endif
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002082
Daniel Dunbard98750f2011-03-18 21:23:40 +00002083 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump1eb44332009-09-09 15:08:12 +00002084 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbard98750f2011-03-18 21:23:40 +00002085 options::OPT_traditional_cpp)) {
2086 if (isa<PreprocessJobAction>(JA))
2087 CmdArgs.push_back("-traditional-cpp");
2088 else
2089 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
2090 }
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00002091
Daniel Dunbar1d460332009-03-18 10:01:51 +00002092 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnerd82df3a2009-04-12 01:56:53 +00002093 Args.AddLastArg(CmdArgs, options::OPT_dD);
Daniel Dunbar1d460332009-03-18 10:01:51 +00002094
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00002095 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
2096 // parser.
Daniel Dunbar1d460332009-03-18 10:01:51 +00002097 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00002098 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
2099 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00002100 (*it)->claim();
Daniel Dunbarfb36d212010-04-17 06:10:00 +00002101
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00002102 // We translate this by hand to the -cc1 argument, since nightly test uses
2103 // it and developers have been trained to spell it with -mllvm.
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00002104 if (llvm::StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00002105 CmdArgs.push_back("-disable-llvm-optzns");
2106 else
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00002107 (*it)->render(Args, CmdArgs);
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00002108 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00002109
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +00002110 if (Output.getType() == types::TY_Dependencies) {
2111 // Handled with other dependency code.
Daniel Dunbar115a7922009-03-19 07:29:38 +00002112 } else if (Output.isFilename()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002113 CmdArgs.push_back("-o");
Daniel Dunbar115a7922009-03-19 07:29:38 +00002114 CmdArgs.push_back(Output.getFilename());
2115 } else {
2116 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002117 }
2118
Daniel Dunbar1d460332009-03-18 10:01:51 +00002119 for (InputInfoList::const_iterator
2120 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2121 const InputInfo &II = *it;
2122 CmdArgs.push_back("-x");
2123 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002124 if (II.isFilename())
Daniel Dunbar115a7922009-03-19 07:29:38 +00002125 CmdArgs.push_back(II.getFilename());
Daniel Dunbar1d460332009-03-18 10:01:51 +00002126 else
Daniel Dunbar115a7922009-03-19 07:29:38 +00002127 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00002128 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002129
Chris Lattnere6113de2009-11-03 19:50:27 +00002130 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2131
Daniel Dunbara001c1c2010-07-18 21:16:15 +00002132 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00002133
2134 // Optionally embed the -cc1 level arguments into the debug info, for build
2135 // analysis.
2136 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar6e900472010-06-04 18:47:06 +00002137 ArgStringList OriginalArgs;
2138 for (ArgList::const_iterator it = Args.begin(),
2139 ie = Args.end(); it != ie; ++it)
2140 (*it)->render(Args, OriginalArgs);
Daniel Dunbarca0e0542010-08-24 16:47:49 +00002141
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00002142 llvm::SmallString<256> Flags;
2143 Flags += Exec;
Daniel Dunbar6e900472010-06-04 18:47:06 +00002144 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00002145 Flags += " ";
Daniel Dunbar6e900472010-06-04 18:47:06 +00002146 Flags += OriginalArgs[i];
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00002147 }
2148 CmdArgs.push_back("-dwarf-debug-flags");
2149 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
2150 }
2151
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002152 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbara880db02009-03-23 19:03:36 +00002153
Roman Divackybe4c8702011-02-10 16:52:03 +00002154 if (Arg *A = Args.getLastArg(options::OPT_pg))
2155 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2156 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2157 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002158
Daniel Dunbar68fb4692009-04-03 20:51:31 +00002159 // Claim some arguments which clang supports automatically.
2160
Daniel Dunbarf4046862010-04-15 06:18:42 +00002161 // -fpch-preprocess is used with gcc to add a special marker in the output to
2162 // include the PCH file. Clang's PTH solution is completely transparent, so we
2163 // do not need to deal with it at all.
Daniel Dunbar68fb4692009-04-03 20:51:31 +00002164 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002165
Daniel Dunbara880db02009-03-23 19:03:36 +00002166 // Claim some arguments which clang doesn't support, but we don't
2167 // care to warn the user about.
Daniel Dunbarcdd96862009-11-25 11:53:23 +00002168 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
2169 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola035ff0c2011-02-28 23:29:45 +00002170
Rafael Espindola9c094fb2011-03-01 05:25:27 +00002171 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
Rafael Espindola035ff0c2011-02-28 23:29:45 +00002172 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00002173 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002174}
2175
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002176void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002177 const InputInfo &Output,
2178 const InputInfoList &Inputs,
2179 const ArgList &Args,
2180 const char *LinkingOutput) const {
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002181 ArgStringList CmdArgs;
2182
2183 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2184 const InputInfo &Input = Inputs[0];
2185
Rafael Espindoladbe80d92010-11-17 22:13:25 +00002186 // Don't warn about "clang -w -c foo.s"
2187 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00002188 // and "clang -emit-llvm -c foo.s"
2189 Args.ClaimAllArgs(options::OPT_emit_llvm);
2190 // and "clang -use-gold-plugin -c foo.s"
2191 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindoladbe80d92010-11-17 22:13:25 +00002192
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002193 // Invoke ourselves in -cc1as mode.
2194 //
2195 // FIXME: Implement custom jobs for internal actions.
2196 CmdArgs.push_back("-cc1as");
2197
2198 // Add the "effective" target triple.
2199 CmdArgs.push_back("-triple");
Daniel Dunbar00577ad2010-08-23 22:35:37 +00002200 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002201 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2202
2203 // Set the output mode, we currently only expect to be used as a real
2204 // assembler.
2205 CmdArgs.push_back("-filetype");
2206 CmdArgs.push_back("obj");
2207
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00002208 if (UseRelaxAll(C, Args))
Daniel Dunbar469d40e2010-05-28 16:43:21 +00002209 CmdArgs.push_back("-relax-all");
Daniel Dunbar99298002010-05-27 06:18:05 +00002210
Daniel Dunbar7f6f8c82011-03-17 17:37:29 +00002211 // Ignore explicit -force_cpusubtype_ALL option.
2212 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002213
2214 // FIXME: Add -g support, once we have it.
2215
2216 // FIXME: Add -static support, once we have it.
2217
2218 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2219 options::OPT_Xassembler);
Daniel Dunbar3df23252011-04-29 17:53:18 +00002220 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002221
2222 assert(Output.isFilename() && "Unexpected lipo output.");
2223 CmdArgs.push_back("-o");
2224 CmdArgs.push_back(Output.getFilename());
2225
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002226 assert(Input.isFilename() && "Invalid input.");
2227 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002228
Daniel Dunbara001c1c2010-07-18 21:16:15 +00002229 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002230 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002231}
2232
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002233void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002234 const InputInfo &Output,
2235 const InputInfoList &Inputs,
Daniel Dunbar1d460332009-03-18 10:01:51 +00002236 const ArgList &Args,
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002237 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002238 const Driver &D = getToolChain().getDriver();
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002239 ArgStringList CmdArgs;
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002240
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002241 for (ArgList::const_iterator
Daniel Dunbar1d460332009-03-18 10:01:51 +00002242 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002243 Arg *A = *it;
Daniel Dunbar75877192009-03-19 07:55:12 +00002244 if (A->getOption().hasForwardToGCC()) {
Daniel Dunbar2dffe2d2010-08-03 16:14:14 +00002245 // Don't forward any -g arguments to assembly steps.
2246 if (isa<AssembleJobAction>(JA) &&
2247 A->getOption().matches(options::OPT_g_Group))
2248 continue;
2249
Daniel Dunbar75877192009-03-19 07:55:12 +00002250 // It is unfortunate that we have to claim here, as this means
2251 // we will basically never report anything interesting for
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002252 // platforms using a generic gcc, even if we are just using gcc
2253 // to get to the assembler.
Daniel Dunbar75877192009-03-19 07:55:12 +00002254 A->claim();
Daniel Dunbar1d460332009-03-18 10:01:51 +00002255 A->render(Args, CmdArgs);
Daniel Dunbar75877192009-03-19 07:55:12 +00002256 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002257 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002258
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002259 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002260
2261 // If using a driver driver, force the arch.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002262 const std::string &Arch = getToolChain().getArchName();
Daniel Dunbar1bda4342009-12-23 00:46:38 +00002263 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002264 CmdArgs.push_back("-arch");
Daniel Dunbarbf54a062009-04-01 20:33:11 +00002265
2266 // FIXME: Remove these special cases.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002267 if (Arch == "powerpc")
2268 CmdArgs.push_back("ppc");
2269 else if (Arch == "powerpc64")
2270 CmdArgs.push_back("ppc64");
2271 else
Daniel Dunbar88137642009-09-09 22:32:48 +00002272 CmdArgs.push_back(Args.MakeArgString(Arch));
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002273 }
2274
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002275 // Try to force gcc to match the tool chain we want, if we recognize
2276 // the arch.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002277 //
2278 // FIXME: The triple class should directly provide the information we want
2279 // here.
2280 if (Arch == "i386" || Arch == "powerpc")
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002281 CmdArgs.push_back("-m32");
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002282 else if (Arch == "x86_64" || Arch == "powerpc64")
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002283 CmdArgs.push_back("-m64");
2284
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002285 if (Output.isFilename()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002286 CmdArgs.push_back("-o");
Daniel Dunbar115a7922009-03-19 07:29:38 +00002287 CmdArgs.push_back(Output.getFilename());
2288 } else {
2289 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002290 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar115a7922009-03-19 07:29:38 +00002291 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002292
2293
2294 // Only pass -x if gcc will understand it; otherwise hope gcc
2295 // understands the suffix correctly. The main use case this would go
2296 // wrong in is for linker inputs if they happened to have an odd
2297 // suffix; really the only way to get this to happen is a command
2298 // like '-x foobar a.c' which will treat a.c like a linker input.
2299 //
2300 // FIXME: For the linker case specifically, can we safely convert
2301 // inputs into '-Wl,' options?
2302 for (InputInfoList::const_iterator
2303 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2304 const InputInfo &II = *it;
Daniel Dunbara8304f62009-05-02 20:14:53 +00002305
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002306 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002307 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
2308 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Daniel Dunbara8304f62009-05-02 20:14:53 +00002309 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002310 << getToolChain().getTripleString();
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002311 else if (II.getType() == types::TY_AST)
2312 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002313 << getToolChain().getTripleString();
Daniel Dunbara8304f62009-05-02 20:14:53 +00002314
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002315 if (types::canTypeBeUserSpecified(II.getType())) {
2316 CmdArgs.push_back("-x");
2317 CmdArgs.push_back(types::getTypeName(II.getType()));
2318 }
2319
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002320 if (II.isFilename())
Daniel Dunbar115a7922009-03-19 07:29:38 +00002321 CmdArgs.push_back(II.getFilename());
Daniel Dunbar48f99942010-09-25 18:10:05 +00002322 else {
2323 const Arg &A = II.getInputArg();
2324
2325 // Reverse translate some rewritten options.
2326 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
2327 CmdArgs.push_back("-lstdc++");
2328 continue;
2329 }
2330
Daniel Dunbar115a7922009-03-19 07:29:38 +00002331 // Don't render as input, we need gcc to do the translations.
Daniel Dunbar48f99942010-09-25 18:10:05 +00002332 A.render(Args, CmdArgs);
2333 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002334 }
2335
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +00002336 const std::string customGCCName = D.getCCCGenericGCCName();
2337 const char *GCCName;
2338 if (!customGCCName.empty())
2339 GCCName = customGCCName.c_str();
2340 else if (D.CCCIsCXX) {
2341#ifdef IS_CYGWIN15
2342 // FIXME: Detect the version of Cygwin at runtime?
2343 GCCName = "g++-4";
2344#else
2345 GCCName = "g++";
2346#endif
2347 } else
2348 GCCName = "gcc";
2349
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002350 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002351 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002352 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002353}
2354
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002355void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
2356 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002357 CmdArgs.push_back("-E");
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002358}
2359
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002360void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
2361 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002362 // The type is good enough.
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002363}
2364
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002365void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
2366 ArgStringList &CmdArgs) const {
Daniel Dunbar64952502010-02-11 03:16:21 +00002367 const Driver &D = getToolChain().getDriver();
2368
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002369 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002370 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
2371 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002372 CmdArgs.push_back("-c");
Daniel Dunbar64952502010-02-11 03:16:21 +00002373 else {
2374 if (JA.getType() != types::TY_PP_Asm)
2375 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
2376 << getTypeName(JA.getType());
Michael J. Spencer20249a12010-10-21 03:16:25 +00002377
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002378 CmdArgs.push_back("-S");
Daniel Dunbar64952502010-02-11 03:16:21 +00002379 }
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002380}
2381
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002382void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
2383 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002384 CmdArgs.push_back("-c");
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002385}
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002386
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002387void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
2388 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002389 // The types are (hopefully) good enough.
2390}
2391
Daniel Dunbar40f12652009-03-29 17:08:39 +00002392const char *darwin::CC1::getCC1Name(types::ID Type) const {
2393 switch (Type) {
2394 default:
2395 assert(0 && "Unexpected type for Darwin CC1 tool.");
2396 case types::TY_Asm:
2397 case types::TY_C: case types::TY_CHeader:
2398 case types::TY_PP_C: case types::TY_PP_CHeader:
2399 return "cc1";
2400 case types::TY_ObjC: case types::TY_ObjCHeader:
2401 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader:
2402 return "cc1obj";
2403 case types::TY_CXX: case types::TY_CXXHeader:
2404 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
2405 return "cc1plus";
2406 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
2407 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader:
2408 return "cc1objplus";
2409 }
2410}
2411
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002412const char *darwin::CC1::getBaseInputName(const ArgList &Args,
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002413 const InputInfoList &Inputs) {
Michael J. Spencer472ccff2010-12-18 00:19:12 +00002414 return Args.MakeArgString(
2415 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002416}
2417
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002418const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002419 const InputInfoList &Inputs) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002420 const char *Str = getBaseInputName(Args, Inputs);
2421
Chris Lattner657ca662011-01-16 08:14:11 +00002422 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar88137642009-09-09 22:32:48 +00002423 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002424
2425 return Str;
2426}
2427
2428const char *
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002429darwin::CC1::getDependencyFileName(const ArgList &Args,
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002430 const InputInfoList &Inputs) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002431 // FIXME: Think about this more.
2432 std::string Res;
2433
2434 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2435 std::string Str(OutputOpt->getValue(Args));
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002436
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002437 Res = Str.substr(0, Str.rfind('.'));
2438 } else
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002439 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002440
Daniel Dunbar88137642009-09-09 22:32:48 +00002441 return Args.MakeArgString(Res + ".d");
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002442}
2443
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002444void darwin::CC1::AddCC1Args(const ArgList &Args,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002445 ArgStringList &CmdArgs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002446 const Driver &D = getToolChain().getDriver();
Daniel Dunbare2fd6642009-09-10 01:21:12 +00002447
2448 CheckCodeGenerationOptions(D, Args);
2449
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002450 // Derived from cc1 spec.
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002451 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
2452 !Args.hasArg(options::OPT_mdynamic_no_pic))
2453 CmdArgs.push_back("-fPIC");
2454
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002455 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2456 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2457 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2458 CmdArgs.push_back("-fno-builtin-strcat");
2459 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2460 CmdArgs.push_back("-fno-builtin-strcpy");
2461 }
2462
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002463 if (Args.hasArg(options::OPT_g_Flag) &&
2464 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
2465 CmdArgs.push_back("-feliminate-unused-debug-symbols");
2466}
2467
2468void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2469 const InputInfoList &Inputs,
2470 const ArgStringList &OutputArgs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002471 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002472
2473 // Derived from cc1_options spec.
2474 if (Args.hasArg(options::OPT_fast) ||
2475 Args.hasArg(options::OPT_fastf) ||
2476 Args.hasArg(options::OPT_fastcp))
2477 CmdArgs.push_back("-O3");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002478
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002479 if (Arg *A = Args.getLastArg(options::OPT_pg))
2480 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2481 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2482 << A->getAsString(Args) << "-fomit-frame-pointer";
2483
2484 AddCC1Args(Args, CmdArgs);
2485
2486 if (!Args.hasArg(options::OPT_Q))
2487 CmdArgs.push_back("-quiet");
2488
2489 CmdArgs.push_back("-dumpbase");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002490 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002491
2492 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2493
2494 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2495 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
2496
2497 // FIXME: The goal is to use the user provided -o if that is our
2498 // final output, otherwise to drive from the original input
2499 // name. Find a clean way to go about this.
2500 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
2501 Args.hasArg(options::OPT_o)) {
2502 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
2503 CmdArgs.push_back("-auxbase-strip");
2504 CmdArgs.push_back(OutputOpt->getValue(Args));
2505 } else {
2506 CmdArgs.push_back("-auxbase");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002507 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002508 }
2509
2510 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
2511
2512 Args.AddAllArgs(CmdArgs, options::OPT_O);
2513 // FIXME: -Wall is getting some special treatment. Investigate.
2514 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2515 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002516 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002517 options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00002518 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2519 // Honor -std-default.
2520 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2521 "-std=", /*Joined=*/true);
2522 }
2523
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002524 if (Args.hasArg(options::OPT_v))
2525 CmdArgs.push_back("-version");
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00002526 if (Args.hasArg(options::OPT_pg) &&
2527 getToolChain().SupportsProfiling())
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002528 CmdArgs.push_back("-p");
2529 Args.AddLastArg(CmdArgs, options::OPT_p);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002530
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002531 // The driver treats -fsyntax-only specially.
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002532 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2533 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2534 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
2535 // used to inhibit the default -fno-builtin-str{cat,cpy}.
2536 //
2537 // FIXME: Should we grow a better way to deal with "removing" args?
Daniel Dunbarcdd96862009-11-25 11:53:23 +00002538 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
2539 options::OPT_fsyntax_only),
2540 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00002541 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
2542 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
2543 (*it)->claim();
2544 (*it)->render(Args, CmdArgs);
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002545 }
2546 }
2547 } else
2548 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002549
Daniel Dunbar089f8722011-04-07 20:41:03 +00002550 // Claim Clang only -f options, they aren't worth warning about.
2551 Args.ClaimAllArgs(options::OPT_f_clang_Group);
2552
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002553 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2554 if (Args.hasArg(options::OPT_Qn))
2555 CmdArgs.push_back("-fno-ident");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002556
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002557 // FIXME: This isn't correct.
2558 //Args.AddLastArg(CmdArgs, options::OPT__help)
2559 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
2560
2561 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2562
2563 // FIXME: Still don't get what is happening here. Investigate.
2564 Args.AddAllArgs(CmdArgs, options::OPT__param);
2565
2566 if (Args.hasArg(options::OPT_fmudflap) ||
2567 Args.hasArg(options::OPT_fmudflapth)) {
2568 CmdArgs.push_back("-fno-builtin");
2569 CmdArgs.push_back("-fno-merge-constants");
2570 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002571
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002572 if (Args.hasArg(options::OPT_coverage)) {
2573 CmdArgs.push_back("-fprofile-arcs");
2574 CmdArgs.push_back("-ftest-coverage");
2575 }
2576
2577 if (types::isCXX(Inputs[0].getType()))
2578 CmdArgs.push_back("-D__private_extern__=extern");
2579}
2580
2581void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2582 const InputInfoList &Inputs,
2583 const ArgStringList &OutputArgs) const {
2584 // Derived from cpp_options
2585 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002586
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002587 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2588
2589 AddCC1Args(Args, CmdArgs);
2590
2591 // NOTE: The code below has some commonality with cpp_options, but
2592 // in classic gcc style ends up sending things in different
2593 // orders. This may be a good merge candidate once we drop pedantic
2594 // compatibility.
2595
2596 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002597 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002598 options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00002599 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2600 // Honor -std-default.
2601 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2602 "-std=", /*Joined=*/true);
2603 }
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002604 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2605 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002606
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002607 // The driver treats -fsyntax-only specially.
2608 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2609
Daniel Dunbar089f8722011-04-07 20:41:03 +00002610 // Claim Clang only -f options, they aren't worth warning about.
2611 Args.ClaimAllArgs(options::OPT_f_clang_Group);
2612
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002613 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
2614 !Args.hasArg(options::OPT_fno_working_directory))
2615 CmdArgs.push_back("-fworking-directory");
2616
2617 Args.AddAllArgs(CmdArgs, options::OPT_O);
2618 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2619 if (Args.hasArg(options::OPT_save_temps))
2620 CmdArgs.push_back("-fpch-preprocess");
2621}
2622
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002623void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002624 ArgStringList &CmdArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00002625 const InputInfoList &Inputs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002626 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002627
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +00002628 CheckPreprocessingOptions(D, Args);
2629
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002630 // Derived from cpp_unique_options.
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +00002631 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
2632 Args.AddLastArg(CmdArgs, options::OPT_C);
2633 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002634 if (!Args.hasArg(options::OPT_Q))
2635 CmdArgs.push_back("-quiet");
2636 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
Douglas Gregor4c2bcad2010-03-24 20:13:48 +00002637 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002638 Args.AddLastArg(CmdArgs, options::OPT_v);
2639 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
2640 Args.AddLastArg(CmdArgs, options::OPT_P);
2641
2642 // FIXME: Handle %I properly.
2643 if (getToolChain().getArchName() == "x86_64") {
2644 CmdArgs.push_back("-imultilib");
2645 CmdArgs.push_back("x86_64");
2646 }
2647
2648 if (Args.hasArg(options::OPT_MD)) {
2649 CmdArgs.push_back("-MD");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002650 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002651 }
2652
2653 if (Args.hasArg(options::OPT_MMD)) {
2654 CmdArgs.push_back("-MMD");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002655 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002656 }
2657
2658 Args.AddLastArg(CmdArgs, options::OPT_M);
2659 Args.AddLastArg(CmdArgs, options::OPT_MM);
2660 Args.AddAllArgs(CmdArgs, options::OPT_MF);
2661 Args.AddLastArg(CmdArgs, options::OPT_MG);
2662 Args.AddLastArg(CmdArgs, options::OPT_MP);
2663 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
2664 Args.AddAllArgs(CmdArgs, options::OPT_MT);
2665 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
2666 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
2667 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2668 CmdArgs.push_back("-MQ");
2669 CmdArgs.push_back(OutputOpt->getValue(Args));
2670 }
2671 }
2672
2673 Args.AddLastArg(CmdArgs, options::OPT_remap);
2674 if (Args.hasArg(options::OPT_g3))
2675 CmdArgs.push_back("-dD");
2676 Args.AddLastArg(CmdArgs, options::OPT_H);
2677
2678 AddCPPArgs(Args, CmdArgs);
2679
2680 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
2681 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
2682
2683 for (InputInfoList::const_iterator
2684 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2685 const InputInfo &II = *it;
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002686
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002687 CmdArgs.push_back(II.getFilename());
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002688 }
2689
2690 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
2691 options::OPT_Xpreprocessor);
2692
2693 if (Args.hasArg(options::OPT_fmudflap)) {
2694 CmdArgs.push_back("-D_MUDFLAP");
2695 CmdArgs.push_back("-include");
2696 CmdArgs.push_back("mf-runtime.h");
2697 }
2698
2699 if (Args.hasArg(options::OPT_fmudflapth)) {
2700 CmdArgs.push_back("-D_MUDFLAP");
2701 CmdArgs.push_back("-D_MUDFLAPTH");
2702 CmdArgs.push_back("-include");
2703 CmdArgs.push_back("mf-runtime.h");
2704 }
2705}
2706
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002707void darwin::CC1::AddCPPArgs(const ArgList &Args,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002708 ArgStringList &CmdArgs) const {
2709 // Derived from cpp spec.
2710
2711 if (Args.hasArg(options::OPT_static)) {
2712 // The gcc spec is broken here, it refers to dynamic but
2713 // that has been translated. Start by being bug compatible.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002714
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002715 // if (!Args.hasArg(arglist.parser.dynamicOption))
2716 CmdArgs.push_back("-D__STATIC__");
2717 } else
2718 CmdArgs.push_back("-D__DYNAMIC__");
2719
2720 if (Args.hasArg(options::OPT_pthread))
2721 CmdArgs.push_back("-D_REENTRANT");
2722}
2723
Daniel Dunbar40f12652009-03-29 17:08:39 +00002724void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002725 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002726 const InputInfoList &Inputs,
2727 const ArgList &Args,
Daniel Dunbar40f12652009-03-29 17:08:39 +00002728 const char *LinkingOutput) const {
2729 ArgStringList CmdArgs;
2730
2731 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2732
2733 CmdArgs.push_back("-E");
2734
2735 if (Args.hasArg(options::OPT_traditional) ||
Daniel Dunbar40f12652009-03-29 17:08:39 +00002736 Args.hasArg(options::OPT_traditional_cpp))
2737 CmdArgs.push_back("-traditional-cpp");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002738
Daniel Dunbar40f12652009-03-29 17:08:39 +00002739 ArgStringList OutputArgs;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002740 assert(Output.isFilename() && "Unexpected CC1 output.");
2741 OutputArgs.push_back("-o");
2742 OutputArgs.push_back(Output.getFilename());
Daniel Dunbar40f12652009-03-29 17:08:39 +00002743
Joerg Sonnenberger9ade4ae2011-03-06 23:31:01 +00002744 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
Daniel Dunbar9120f172009-03-29 22:27:40 +00002745 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2746 } else {
2747 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2748 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2749 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002750
Daniel Dunbar8a2073a2009-04-03 01:27:06 +00002751 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2752
Daniel Dunbar40f12652009-03-29 17:08:39 +00002753 const char *CC1Name = getCC1Name(Inputs[0].getType());
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002754 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002755 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002756 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar40f12652009-03-29 17:08:39 +00002757}
2758
2759void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002760 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002761 const InputInfoList &Inputs,
2762 const ArgList &Args,
Daniel Dunbar40f12652009-03-29 17:08:39 +00002763 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002764 const Driver &D = getToolChain().getDriver();
Daniel Dunbar40f12652009-03-29 17:08:39 +00002765 ArgStringList CmdArgs;
2766
2767 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2768
2769 types::ID InputType = Inputs[0].getType();
2770 const Arg *A;
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00002771 if ((A = Args.getLastArg(options::OPT_traditional)))
Daniel Dunbar40f12652009-03-29 17:08:39 +00002772 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2773 << A->getAsString(Args) << "-E";
2774
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002775 if (JA.getType() == types::TY_LLVM_IR ||
2776 JA.getType() == types::TY_LTO_IR)
Daniel Dunbar40f12652009-03-29 17:08:39 +00002777 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002778 else if (JA.getType() == types::TY_LLVM_BC ||
2779 JA.getType() == types::TY_LTO_BC)
Daniel Dunbar40f12652009-03-29 17:08:39 +00002780 CmdArgs.push_back("-emit-llvm-bc");
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002781 else if (Output.getType() == types::TY_AST)
2782 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002783 << getToolChain().getTripleString();
Daniel Dunbarae24a882010-02-11 17:33:45 +00002784 else if (JA.getType() != types::TY_PP_Asm &&
2785 JA.getType() != types::TY_PCH)
Daniel Dunbar64952502010-02-11 03:16:21 +00002786 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
2787 << getTypeName(JA.getType());
Daniel Dunbar40f12652009-03-29 17:08:39 +00002788
2789 ArgStringList OutputArgs;
2790 if (Output.getType() != types::TY_PCH) {
2791 OutputArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002792 if (Output.isNothing())
Daniel Dunbar40f12652009-03-29 17:08:39 +00002793 OutputArgs.push_back("/dev/null");
2794 else
2795 OutputArgs.push_back(Output.getFilename());
2796 }
2797
2798 // There is no need for this level of compatibility, but it makes
2799 // diffing easier.
2800 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
2801 Args.hasArg(options::OPT_S));
2802
2803 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002804 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
Daniel Dunbar40f12652009-03-29 17:08:39 +00002805 if (OutputArgsEarly) {
2806 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2807 } else {
2808 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2809 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2810 }
2811 } else {
2812 CmdArgs.push_back("-fpreprocessed");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002813
Daniel Dunbar40f12652009-03-29 17:08:39 +00002814 for (InputInfoList::const_iterator
2815 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2816 const InputInfo &II = *it;
2817
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002818 // Reject AST inputs.
2819 if (II.getType() == types::TY_AST) {
2820 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002821 << getToolChain().getTripleString();
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002822 return;
2823 }
2824
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002825 CmdArgs.push_back(II.getFilename());
Daniel Dunbar40f12652009-03-29 17:08:39 +00002826 }
2827
2828 if (OutputArgsEarly) {
2829 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2830 } else {
2831 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2832 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2833 }
2834 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002835
Daniel Dunbar40f12652009-03-29 17:08:39 +00002836 if (Output.getType() == types::TY_PCH) {
2837 assert(Output.isFilename() && "Invalid PCH output.");
2838
2839 CmdArgs.push_back("-o");
2840 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
2841 // to be a good reason.
2842 CmdArgs.push_back("/dev/null");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002843
Daniel Dunbare6c9ae12009-11-21 02:31:29 +00002844 CmdArgs.push_back("--output-pch=");
Daniel Dunbar40f12652009-03-29 17:08:39 +00002845 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002846 }
Daniel Dunbar40f12652009-03-29 17:08:39 +00002847
2848 const char *CC1Name = getCC1Name(Inputs[0].getType());
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002849 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002850 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002851 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar40f12652009-03-29 17:08:39 +00002852}
2853
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002854void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002855 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002856 const InputInfoList &Inputs,
2857 const ArgList &Args,
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002858 const char *LinkingOutput) const {
2859 ArgStringList CmdArgs;
2860
2861 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2862 const InputInfo &Input = Inputs[0];
2863
Daniel Dunbar34bac1f2011-04-12 23:59:20 +00002864 // Determine the original source input.
2865 const Action *SourceAction = &JA;
2866 while (SourceAction->getKind() != Action::InputClass) {
2867 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
2868 SourceAction = SourceAction->getInputs()[0];
2869 }
2870
2871 // Forward -g, assuming we are dealing with an actual assembly file.
2872 if (SourceAction->getType() == types::TY_Asm ||
2873 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar8e4fea62009-04-01 00:27:44 +00002874 if (Args.hasArg(options::OPT_gstabs))
2875 CmdArgs.push_back("--gstabs");
2876 else if (Args.hasArg(options::OPT_g_Group))
2877 CmdArgs.push_back("--gdwarf2");
2878 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002879
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002880 // Derived from asm spec.
Daniel Dunbarcc6f8032009-09-09 18:36:27 +00002881 AddDarwinArch(Args, CmdArgs);
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002882
Daniel Dunbarf5438e32010-07-22 01:47:22 +00002883 // Use -force_cpusubtype_ALL on x86 by default.
2884 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
2885 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbarcc6f8032009-09-09 18:36:27 +00002886 Args.hasArg(options::OPT_force__cpusubtype__ALL))
2887 CmdArgs.push_back("-force_cpusubtype_ALL");
2888
Daniel Dunbar0e2679d2009-08-24 22:26:16 +00002889 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
2890 (Args.hasArg(options::OPT_mkernel) ||
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002891 Args.hasArg(options::OPT_static) ||
Daniel Dunbar0e2679d2009-08-24 22:26:16 +00002892 Args.hasArg(options::OPT_fapple_kext)))
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002893 CmdArgs.push_back("-static");
2894
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002895 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2896 options::OPT_Xassembler);
2897
2898 assert(Output.isFilename() && "Unexpected lipo output.");
2899 CmdArgs.push_back("-o");
2900 CmdArgs.push_back(Output.getFilename());
2901
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002902 assert(Input.isFilename() && "Invalid input.");
2903 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002904
2905 // asm_final spec is empty.
2906
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002907 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002908 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002909 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002910}
Daniel Dunbarff7488d2009-03-20 00:52:38 +00002911
Daniel Dunbarfbefe6b2009-09-09 18:36:20 +00002912void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
2913 ArgStringList &CmdArgs) const {
Daniel Dunbareeff4062010-01-22 02:04:58 +00002914 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
2915
Daniel Dunbar02633b52009-03-26 16:23:12 +00002916 // Derived from darwin_arch spec.
2917 CmdArgs.push_back("-arch");
Daniel Dunbareeff4062010-01-22 02:04:58 +00002918 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar78dbd582009-09-04 18:35:31 +00002919
Daniel Dunbareeff4062010-01-22 02:04:58 +00002920 // FIXME: Is this needed anymore?
2921 if (ArchName == "arm")
Daniel Dunbar78dbd582009-09-04 18:35:31 +00002922 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbar02633b52009-03-26 16:23:12 +00002923}
2924
Daniel Dunbar748de8e2010-09-09 21:51:05 +00002925void darwin::Link::AddLinkArgs(Compilation &C,
2926 const ArgList &Args,
Daniel Dunbar02633b52009-03-26 16:23:12 +00002927 ArgStringList &CmdArgs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002928 const Driver &D = getToolChain().getDriver();
Daniel Dunbarce911f52011-04-28 21:23:41 +00002929 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbar02633b52009-03-26 16:23:12 +00002930
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00002931 unsigned Version[3] = { 0, 0, 0 };
2932 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2933 bool HadExtra;
2934 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
2935 Version[1], Version[2], HadExtra) ||
2936 HadExtra)
2937 D.Diag(clang::diag::err_drv_invalid_version_number)
2938 << A->getAsString(Args);
2939 }
2940
2941 // Newer linkers support -demangle, pass it if supported and not disabled by
2942 // the user.
Daniel Dunbara30d6cd2010-11-19 17:51:40 +00002943 //
2944 // FIXME: We temporarily avoid passing -demangle to any iOS linker, because
2945 // unfortunately we can't be guaranteed that the linker version used there
2946 // will match the linker version detected at configure time. We need the
2947 // universal driver.
2948 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) &&
Daniel Dunbarce911f52011-04-28 21:23:41 +00002949 !DarwinTC.isTargetIPhoneOS()) {
Daniel Dunbarbcf1da82010-09-07 17:07:49 +00002950 // Don't pass -demangle to ld_classic.
2951 //
2952 // FIXME: This is a temporary workaround, ld should be handling this.
2953 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
2954 Args.hasArg(options::OPT_static));
Daniel Dunbar9ced7042010-09-07 17:50:41 +00002955 if (getToolChain().getArch() == llvm::Triple::x86) {
2956 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
2957 options::OPT_Wl_COMMA),
2958 ie = Args.filtered_end(); it != ie; ++it) {
2959 const Arg *A = *it;
2960 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
2961 if (llvm::StringRef(A->getValue(Args, i)) == "-kext")
2962 UsesLdClassic = true;
2963 }
2964 }
Daniel Dunbarbcf1da82010-09-07 17:07:49 +00002965 if (!UsesLdClassic)
2966 CmdArgs.push_back("-demangle");
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00002967 }
2968
Daniel Dunbar5bfa6562011-06-21 20:55:11 +00002969 // If we are using LTO, then automatically create a temporary file path for
2970 // the linker to use, so that it's lifetime will extend past a possible
2971 // dsymutil step.
Daniel Dunbara68e1c32011-06-21 21:18:32 +00002972 if (Version[0] >= 116 && D.IsUsingLTO(Args)) {
Daniel Dunbar5bfa6562011-06-21 20:55:11 +00002973 const char *TmpPath = C.getArgs().MakeArgString(
2974 D.GetTemporaryPath(types::getTypeTempSuffix(types::TY_Object)));
2975 C.addTempFile(TmpPath);
2976 CmdArgs.push_back("-object_path_lto");
2977 CmdArgs.push_back(TmpPath);
2978 }
2979
Daniel Dunbar02633b52009-03-26 16:23:12 +00002980 // Derived from the "link" spec.
2981 Args.AddAllArgs(CmdArgs, options::OPT_static);
2982 if (!Args.hasArg(options::OPT_static))
2983 CmdArgs.push_back("-dynamic");
2984 if (Args.hasArg(options::OPT_fgnu_runtime)) {
2985 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
2986 // here. How do we wish to handle such things?
2987 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002988
Daniel Dunbar02633b52009-03-26 16:23:12 +00002989 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara6d38492010-01-22 02:04:52 +00002990 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara6d38492010-01-22 02:04:52 +00002991 // FIXME: Why do this only on this path?
Daniel Dunbar8917dd42010-01-22 03:37:33 +00002992 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbar02633b52009-03-26 16:23:12 +00002993
2994 Args.AddLastArg(CmdArgs, options::OPT_bundle);
2995 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
2996 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
2997
2998 Arg *A;
2999 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
3000 (A = Args.getLastArg(options::OPT_current__version)) ||
3001 (A = Args.getLastArg(options::OPT_install__name)))
3002 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
3003 << A->getAsString(Args) << "-dynamiclib";
3004
3005 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
3006 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
3007 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
3008 } else {
3009 CmdArgs.push_back("-dylib");
3010
3011 Arg *A;
3012 if ((A = Args.getLastArg(options::OPT_bundle)) ||
3013 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
3014 (A = Args.getLastArg(options::OPT_client__name)) ||
3015 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
3016 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
3017 (A = Args.getLastArg(options::OPT_private__bundle)))
3018 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
3019 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003020
Daniel Dunbar02633b52009-03-26 16:23:12 +00003021 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
3022 "-dylib_compatibility_version");
3023 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
3024 "-dylib_current_version");
3025
Daniel Dunbara6d38492010-01-22 02:04:52 +00003026 AddDarwinArch(Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003027
3028 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
3029 "-dylib_install_name");
3030 }
3031
3032 Args.AddLastArg(CmdArgs, options::OPT_all__load);
3033 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
3034 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarce911f52011-04-28 21:23:41 +00003035 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00003036 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003037 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
3038 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
3039 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
3040 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
3041 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
3042 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar99ca47b2011-06-28 20:16:02 +00003043 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003044 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
3045 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
3046 Args.AddAllArgs(CmdArgs, options::OPT_init);
3047
Daniel Dunbarce911f52011-04-28 21:23:41 +00003048 // Add the deployment target.
3049 unsigned TargetVersion[3];
3050 DarwinTC.getTargetVersion(TargetVersion);
Daniel Dunbarb7f5ef72011-04-30 04:22:58 +00003051
3052 // If we had an explicit -mios-simulator-version-min argument, honor that,
3053 // otherwise use the traditional deployment targets. We can't just check the
3054 // is-sim attribute because existing code follows this path, and the linker
3055 // may not handle the argument.
3056 //
3057 // FIXME: We may be able to remove this, once we can verify no one depends on
3058 // it.
3059 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
3060 CmdArgs.push_back("-ios_simulator_version_min");
3061 else if (DarwinTC.isTargetIPhoneOS())
3062 CmdArgs.push_back("-iphoneos_version_min");
3063 else
3064 CmdArgs.push_back("-macosx_version_min");
Daniel Dunbarce911f52011-04-28 21:23:41 +00003065 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(TargetVersion[0]) + "." +
3066 llvm::Twine(TargetVersion[1]) + "." +
3067 llvm::Twine(TargetVersion[2])));
3068
Daniel Dunbar02633b52009-03-26 16:23:12 +00003069 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
3070 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
3071 Args.AddLastArg(CmdArgs, options::OPT_single__module);
3072 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
3073 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003074
Daniel Dunbar47e879d2010-07-13 23:31:40 +00003075 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
3076 options::OPT_fno_pie,
3077 options::OPT_fno_PIE)) {
3078 if (A->getOption().matches(options::OPT_fpie) ||
3079 A->getOption().matches(options::OPT_fPIE))
3080 CmdArgs.push_back("-pie");
3081 else
3082 CmdArgs.push_back("-no_pie");
3083 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003084
3085 Args.AddLastArg(CmdArgs, options::OPT_prebind);
3086 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
3087 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
3088 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
3089 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
3090 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
3091 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
3092 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
3093 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
3094 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
3095 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
3096 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
3097 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
3098 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
3099 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
3100 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00003101
Daniel Dunbarcc957192011-05-02 21:03:47 +00003102 // Give --sysroot= preference, over the Apple specific behavior to also use
3103 // --isysroot as the syslibroot.
3104 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
3105 CmdArgs.push_back("-syslibroot");
3106 CmdArgs.push_back(A->getValue(Args));
3107 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
3108 CmdArgs.push_back("-syslibroot");
3109 CmdArgs.push_back(A->getValue(Args));
3110 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3111 CmdArgs.push_back("-syslibroot");
3112 CmdArgs.push_back("/Developer/SDKs/Extra");
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00003113 }
3114
Daniel Dunbar02633b52009-03-26 16:23:12 +00003115 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
3116 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
3117 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
3118 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
3119 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00003120 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003121 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
3122 Args.AddAllArgs(CmdArgs, options::OPT_y);
3123 Args.AddLastArg(CmdArgs, options::OPT_w);
3124 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
3125 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
3126 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
3127 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
3128 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
3129 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
3130 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
3131 Args.AddLastArg(CmdArgs, options::OPT_whyload);
3132 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
3133 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
3134 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
3135 Args.AddLastArg(CmdArgs, options::OPT_Mach);
3136}
3137
3138void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003139 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003140 const InputInfoList &Inputs,
3141 const ArgList &Args,
Daniel Dunbar02633b52009-03-26 16:23:12 +00003142 const char *LinkingOutput) const {
3143 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbare0be8b12009-09-08 16:39:16 +00003144
Daniel Dunbar02633b52009-03-26 16:23:12 +00003145 // The logic here is derived from gcc's behavior; most of which
3146 // comes from specs (starting with link_command). Consult gcc for
3147 // more information.
Daniel Dunbar02633b52009-03-26 16:23:12 +00003148 ArgStringList CmdArgs;
3149
3150 // I'm not sure why this particular decomposition exists in gcc, but
3151 // we follow suite for ease of comparison.
Daniel Dunbar748de8e2010-09-09 21:51:05 +00003152 AddLinkArgs(C, Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003153
Daniel Dunbar02633b52009-03-26 16:23:12 +00003154 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
3155 Args.AddAllArgs(CmdArgs, options::OPT_s);
3156 Args.AddAllArgs(CmdArgs, options::OPT_t);
3157 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3158 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
3159 Args.AddAllArgs(CmdArgs, options::OPT_A);
3160 Args.AddLastArg(CmdArgs, options::OPT_e);
3161 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
3162 Args.AddAllArgs(CmdArgs, options::OPT_r);
3163
Daniel Dunbar270073c2010-10-18 22:08:36 +00003164 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
3165 // members of static archive libraries which implement Objective-C classes or
3166 // categories.
3167 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
3168 CmdArgs.push_back("-ObjC");
Michael J. Spencer20249a12010-10-21 03:16:25 +00003169
Daniel Dunbar02633b52009-03-26 16:23:12 +00003170 CmdArgs.push_back("-o");
3171 CmdArgs.push_back(Output.getFilename());
3172
Daniel Dunbar02633b52009-03-26 16:23:12 +00003173 if (!Args.hasArg(options::OPT_A) &&
3174 !Args.hasArg(options::OPT_nostdlib) &&
3175 !Args.hasArg(options::OPT_nostartfiles)) {
3176 // Derived from startfile spec.
3177 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003178 // Derived from darwin_dylib1 spec.
Daniel Dunbar1051fc02011-04-01 21:02:42 +00003179 if (getDarwinToolChain().isTargetIOSSimulator()) {
3180 // The simulator doesn't have a versioned crt1 file.
3181 CmdArgs.push_back("-ldylib1.o");
3182 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003183 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3184 CmdArgs.push_back("-ldylib1.o");
3185 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003186 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003187 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003188 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003189 CmdArgs.push_back("-ldylib1.10.5.o");
3190 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003191 } else {
3192 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbar8a8d8af2009-04-01 03:17:40 +00003193 if (!Args.hasArg(options::OPT_static)) {
3194 // Derived from darwin_bundle1 spec.
Daniel Dunbar1051fc02011-04-01 21:02:42 +00003195 if (getDarwinToolChain().isTargetIOSSimulator()) {
3196 // The simulator doesn't have a versioned crt1 file.
3197 CmdArgs.push_back("-lbundle1.o");
3198 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003199 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3200 CmdArgs.push_back("-lbundle1.o");
3201 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003202 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003203 CmdArgs.push_back("-lbundle1.o");
3204 }
Daniel Dunbar8a8d8af2009-04-01 03:17:40 +00003205 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003206 } else {
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00003207 if (Args.hasArg(options::OPT_pg) &&
3208 getToolChain().SupportsProfiling()) {
Daniel Dunbar02633b52009-03-26 16:23:12 +00003209 if (Args.hasArg(options::OPT_static) ||
3210 Args.hasArg(options::OPT_object) ||
3211 Args.hasArg(options::OPT_preload)) {
3212 CmdArgs.push_back("-lgcrt0.o");
3213 } else {
3214 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003215
Daniel Dunbar02633b52009-03-26 16:23:12 +00003216 // darwin_crt2 spec is empty.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003217 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003218 } else {
3219 if (Args.hasArg(options::OPT_static) ||
3220 Args.hasArg(options::OPT_object) ||
3221 Args.hasArg(options::OPT_preload)) {
3222 CmdArgs.push_back("-lcrt0.o");
3223 } else {
3224 // Derived from darwin_crt1 spec.
Daniel Dunbar40355802011-03-31 17:12:33 +00003225 if (getDarwinToolChain().isTargetIOSSimulator()) {
3226 // The simulator doesn't have a versioned crt1 file.
3227 CmdArgs.push_back("-lcrt1.o");
3228 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003229 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3230 CmdArgs.push_back("-lcrt1.o");
3231 else
3232 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003233 } else {
3234 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
3235 CmdArgs.push_back("-lcrt1.o");
3236 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3237 CmdArgs.push_back("-lcrt1.10.5.o");
3238 else
3239 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003240
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003241 // darwin_crt2 spec is empty.
3242 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003243 }
3244 }
3245 }
3246 }
3247
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003248 if (!getDarwinToolChain().isTargetIPhoneOS() &&
3249 Args.hasArg(options::OPT_shared_libgcc) &&
3250 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar88137642009-09-09 22:32:48 +00003251 const char *Str =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003252 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar88137642009-09-09 22:32:48 +00003253 CmdArgs.push_back(Str);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003254 }
3255 }
3256
3257 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003258
Daniel Dunbar02633b52009-03-26 16:23:12 +00003259 if (Args.hasArg(options::OPT_fopenmp))
3260 // This is more complicated in gcc...
3261 CmdArgs.push_back("-lgomp");
3262
Daniel Dunbar6b200b22009-09-18 08:14:36 +00003263 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003264
John McCallf85e1932011-06-15 23:02:42 +00003265 // In ARC, if we don't have runtime support, link in the runtime
3266 // stubs. We have to do this *before* adding any of the normal
3267 // linker inputs so that its initializer gets run first.
John McCall9f084a32011-07-06 00:26:06 +00003268 if (isObjCAutoRefCount(Args)) {
3269 ObjCRuntime runtime;
3270 getDarwinToolChain().configureObjCRuntime(runtime);
3271 if (!runtime.HasARC)
3272 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
3273 }
John McCallf85e1932011-06-15 23:02:42 +00003274
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003275 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003276
3277 if (LinkingOutput) {
3278 CmdArgs.push_back("-arch_multiple");
3279 CmdArgs.push_back("-final_output");
3280 CmdArgs.push_back(LinkingOutput);
3281 }
3282
Daniel Dunbar02633b52009-03-26 16:23:12 +00003283 if (Args.hasArg(options::OPT_fnested_functions))
3284 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003285
Daniel Dunbar02633b52009-03-26 16:23:12 +00003286 if (!Args.hasArg(options::OPT_nostdlib) &&
3287 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003288 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar132e35d2010-09-17 01:20:05 +00003289 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbaredfa02b2009-04-08 06:06:21 +00003290
Daniel Dunbar02633b52009-03-26 16:23:12 +00003291 // link_ssp spec is empty.
3292
Daniel Dunbar6cd41542009-09-18 08:15:03 +00003293 // Let the tool chain choose which runtime library to link.
3294 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003295 }
3296
3297 if (!Args.hasArg(options::OPT_A) &&
3298 !Args.hasArg(options::OPT_nostdlib) &&
3299 !Args.hasArg(options::OPT_nostartfiles)) {
3300 // endfile_spec is empty.
3301 }
3302
Bill Wendling3f4be6f2011-06-27 19:15:03 +00003303 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00003304
Daniel Dunbar02633b52009-03-26 16:23:12 +00003305 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3306 Args.AddAllArgs(CmdArgs, options::OPT_F);
3307
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003308 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003309 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003310 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar02633b52009-03-26 16:23:12 +00003311}
3312
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003313void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003314 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003315 const InputInfoList &Inputs,
3316 const ArgList &Args,
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003317 const char *LinkingOutput) const {
3318 ArgStringList CmdArgs;
3319
3320 CmdArgs.push_back("-create");
3321 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbara428df82009-03-24 00:24:37 +00003322
3323 CmdArgs.push_back("-output");
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003324 CmdArgs.push_back(Output.getFilename());
Daniel Dunbara428df82009-03-24 00:24:37 +00003325
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003326 for (InputInfoList::const_iterator
3327 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3328 const InputInfo &II = *it;
3329 assert(II.isFilename() && "Unexpected lipo input.");
3330 CmdArgs.push_back(II.getFilename());
3331 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003332 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003333 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003334 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003335}
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003336
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003337void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003338 const InputInfo &Output,
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003339 const InputInfoList &Inputs,
3340 const ArgList &Args,
3341 const char *LinkingOutput) const {
3342 ArgStringList CmdArgs;
3343
Daniel Dunbar03e92302011-05-09 17:23:16 +00003344 CmdArgs.push_back("-o");
3345 CmdArgs.push_back(Output.getFilename());
3346
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003347 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
3348 const InputInfo &Input = Inputs[0];
3349 assert(Input.isFilename() && "Unexpected dsymutil input.");
3350 CmdArgs.push_back(Input.getFilename());
3351
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003352 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003353 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003354 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003355}
3356
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003357void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003358 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00003359 const InputInfoList &Inputs,
3360 const ArgList &Args,
3361 const char *LinkingOutput) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003362 ArgStringList CmdArgs;
3363
3364 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3365 options::OPT_Xassembler);
3366
3367 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003368 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003369
3370 for (InputInfoList::const_iterator
3371 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3372 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003373 CmdArgs.push_back(II.getFilename());
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003374 }
3375
3376 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003377 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003378 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003379}
3380
3381void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003382 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00003383 const InputInfoList &Inputs,
3384 const ArgList &Args,
3385 const char *LinkingOutput) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003386 ArgStringList CmdArgs;
3387
3388 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar294691e2009-11-04 06:24:38 +00003389 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003390 CmdArgs.push_back("-e");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00003391 CmdArgs.push_back("_start");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003392 }
3393
3394 if (Args.hasArg(options::OPT_static)) {
3395 CmdArgs.push_back("-Bstatic");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00003396 CmdArgs.push_back("-dn");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003397 } else {
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00003398// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003399 CmdArgs.push_back("-Bdynamic");
3400 if (Args.hasArg(options::OPT_shared)) {
3401 CmdArgs.push_back("-shared");
3402 } else {
Edward O'Callaghan3cecc192009-10-16 19:44:18 +00003403 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003404 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
3405 }
3406 }
3407
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003408 if (Output.isFilename()) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003409 CmdArgs.push_back("-o");
3410 CmdArgs.push_back(Output.getFilename());
3411 } else {
3412 assert(Output.isNothing() && "Invalid output.");
3413 }
3414
3415 if (!Args.hasArg(options::OPT_nostdlib) &&
3416 !Args.hasArg(options::OPT_nostartfiles)) {
3417 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00003418 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003419 getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003420 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003421 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003422 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003423 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003424 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00003425 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003426 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003427 }
Chris Lattner38e317d2010-07-07 16:01:42 +00003428 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003429 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003430 }
3431
Daniel Dunbar294691e2009-11-04 06:24:38 +00003432 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
3433 + getToolChain().getTripleString()
Daniel Dunbarf7fb31f2009-10-29 02:24:37 +00003434 + "/4.2.4"));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003435
3436 Args.AddAllArgs(CmdArgs, options::OPT_L);
3437 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3438 Args.AddAllArgs(CmdArgs, options::OPT_e);
3439
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003440 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003441
3442 if (!Args.hasArg(options::OPT_nostdlib) &&
3443 !Args.hasArg(options::OPT_nodefaultlibs)) {
3444 // FIXME: For some reason GCC passes -lgcc before adding
3445 // the default system libraries. Just mimic this for now.
3446 CmdArgs.push_back("-lgcc");
3447
3448 if (Args.hasArg(options::OPT_pthread))
3449 CmdArgs.push_back("-pthread");
3450 if (!Args.hasArg(options::OPT_shared))
3451 CmdArgs.push_back("-lc");
3452 CmdArgs.push_back("-lgcc");
3453 }
3454
3455 if (!Args.hasArg(options::OPT_nostdlib) &&
3456 !Args.hasArg(options::OPT_nostartfiles)) {
3457 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00003458 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003459 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003460 }
3461
Bill Wendling3f4be6f2011-06-27 19:15:03 +00003462 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00003463
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003464 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003465 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003466 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003467}
3468
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003469void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003470 const InputInfo &Output,
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003471 const InputInfoList &Inputs,
3472 const ArgList &Args,
Mike Stump1eb44332009-09-09 15:08:12 +00003473 const char *LinkingOutput) const {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003474 ArgStringList CmdArgs;
3475
3476 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3477 options::OPT_Xassembler);
3478
3479 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003480 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003481
3482 for (InputInfoList::const_iterator
3483 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3484 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003485 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003486 }
3487
3488 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003489 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003490 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003491}
3492
3493void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003494 const InputInfo &Output,
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003495 const InputInfoList &Inputs,
3496 const ArgList &Args,
3497 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003498 const Driver &D = getToolChain().getDriver();
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003499 ArgStringList CmdArgs;
3500
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003501 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar294691e2009-11-04 06:24:38 +00003502 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003503 CmdArgs.push_back("-e");
3504 CmdArgs.push_back("__start");
3505 }
3506
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003507 if (Args.hasArg(options::OPT_static)) {
3508 CmdArgs.push_back("-Bstatic");
3509 } else {
Rafael Espindola65ba55d2010-11-11 02:17:51 +00003510 if (Args.hasArg(options::OPT_rdynamic))
3511 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003512 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003513 CmdArgs.push_back("-Bdynamic");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003514 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003515 CmdArgs.push_back("-shared");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003516 } else {
3517 CmdArgs.push_back("-dynamic-linker");
3518 CmdArgs.push_back("/usr/libexec/ld.so");
3519 }
3520 }
3521
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003522 if (Output.isFilename()) {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003523 CmdArgs.push_back("-o");
3524 CmdArgs.push_back(Output.getFilename());
3525 } else {
3526 assert(Output.isNothing() && "Invalid output.");
3527 }
3528
3529 if (!Args.hasArg(options::OPT_nostdlib) &&
3530 !Args.hasArg(options::OPT_nostartfiles)) {
3531 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00003532 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003533 getToolChain().GetFilePath("crt0.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003534 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003535 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003536 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00003537 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003538 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003539 }
3540 }
3541
Edward O'Callaghane7e18202009-10-28 15:13:08 +00003542 std::string Triple = getToolChain().getTripleString();
3543 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar294691e2009-11-04 06:24:38 +00003544 Triple.replace(0, 6, "amd64");
Daniel Dunbarf7fb31f2009-10-29 02:24:37 +00003545 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbar95c04572010-08-01 23:13:54 +00003546 "/4.2.1"));
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003547
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003548 Args.AddAllArgs(CmdArgs, options::OPT_L);
3549 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3550 Args.AddAllArgs(CmdArgs, options::OPT_e);
3551
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003552 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003553
3554 if (!Args.hasArg(options::OPT_nostdlib) &&
3555 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar95c04572010-08-01 23:13:54 +00003556 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00003557 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbar95c04572010-08-01 23:13:54 +00003558 CmdArgs.push_back("-lm");
3559 }
3560
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003561 // FIXME: For some reason GCC passes -lgcc before adding
3562 // the default system libraries. Just mimic this for now.
3563 CmdArgs.push_back("-lgcc");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003564
3565 if (Args.hasArg(options::OPT_pthread))
Chris Lattnera2e40212011-02-21 18:36:51 +00003566 CmdArgs.push_back("-lpthread");
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003567 if (!Args.hasArg(options::OPT_shared))
3568 CmdArgs.push_back("-lc");
3569 CmdArgs.push_back("-lgcc");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003570 }
3571
3572 if (!Args.hasArg(options::OPT_nostdlib) &&
3573 !Args.hasArg(options::OPT_nostartfiles)) {
3574 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00003575 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003576 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003577 else
Chris Lattner38e317d2010-07-07 16:01:42 +00003578 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003579 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003580 }
3581
3582 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003583 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003584 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003585}
Ed Schoutenc66a5a32009-04-02 19:13:12 +00003586
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003587void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003588 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003589 const InputInfoList &Inputs,
3590 const ArgList &Args,
Mike Stump1eb44332009-09-09 15:08:12 +00003591 const char *LinkingOutput) const {
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003592 ArgStringList CmdArgs;
3593
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003594 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3595 // instruct as in the base system to assemble 32-bit code.
3596 if (getToolChain().getArchName() == "i386")
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003597 CmdArgs.push_back("--32");
3598
Roman Divacky3393cef2011-06-04 07:37:31 +00003599 if (getToolChain().getArchName() == "powerpc")
3600 CmdArgs.push_back("-a32");
Michael J. Spencer20249a12010-10-21 03:16:25 +00003601
Eric Christophered734732010-03-02 02:41:08 +00003602 // Set byte order explicitly
3603 if (getToolChain().getArchName() == "mips")
3604 CmdArgs.push_back("-EB");
3605 else if (getToolChain().getArchName() == "mipsel")
3606 CmdArgs.push_back("-EL");
3607
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003608 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3609 options::OPT_Xassembler);
3610
3611 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003612 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003613
3614 for (InputInfoList::const_iterator
3615 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3616 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003617 CmdArgs.push_back(II.getFilename());
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003618 }
3619
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003620 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003621 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003622 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003623}
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003624
3625void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003626 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003627 const InputInfoList &Inputs,
3628 const ArgList &Args,
Daniel Dunbara8304f62009-05-02 20:14:53 +00003629 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003630 const Driver &D = getToolChain().getDriver();
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003631 ArgStringList CmdArgs;
3632
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00003633 if (!D.SysRoot.empty())
3634 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
3635
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003636 if (Args.hasArg(options::OPT_static)) {
3637 CmdArgs.push_back("-Bstatic");
3638 } else {
Rafael Espindola65ba55d2010-11-11 02:17:51 +00003639 if (Args.hasArg(options::OPT_rdynamic))
3640 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003641 CmdArgs.push_back("--eh-frame-hdr");
3642 if (Args.hasArg(options::OPT_shared)) {
3643 CmdArgs.push_back("-Bshareable");
3644 } else {
3645 CmdArgs.push_back("-dynamic-linker");
3646 CmdArgs.push_back("/libexec/ld-elf.so.1");
3647 }
3648 }
3649
3650 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3651 // instruct ld in the base system to link 32-bit code.
3652 if (getToolChain().getArchName() == "i386") {
3653 CmdArgs.push_back("-m");
3654 CmdArgs.push_back("elf_i386_fbsd");
3655 }
3656
Roman Divacky000a6552011-06-04 07:40:24 +00003657 if (getToolChain().getArchName() == "powerpc") {
3658 CmdArgs.push_back("-m");
3659 CmdArgs.push_back("elf32ppc");
3660 }
3661
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003662 if (Output.isFilename()) {
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003663 CmdArgs.push_back("-o");
3664 CmdArgs.push_back(Output.getFilename());
3665 } else {
3666 assert(Output.isNothing() && "Invalid output.");
3667 }
3668
3669 if (!Args.hasArg(options::OPT_nostdlib) &&
3670 !Args.hasArg(options::OPT_nostartfiles)) {
3671 if (!Args.hasArg(options::OPT_shared)) {
Roman Divackyc16bb762011-02-10 16:59:40 +00003672 if (Args.hasArg(options::OPT_pg))
3673 CmdArgs.push_back(Args.MakeArgString(
3674 getToolChain().GetFilePath("gcrt1.o")));
3675 else
3676 CmdArgs.push_back(Args.MakeArgString(
3677 getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003678 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003679 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003680 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003681 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003682 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00003683 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003684 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003685 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003686 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003687 }
3688 }
3689
3690 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divacky58e5ac92011-03-01 17:53:14 +00003691 const ToolChain::path_list Paths = getToolChain().getFilePaths();
3692 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
3693 i != e; ++i)
3694 CmdArgs.push_back(Args.MakeArgString(llvm::StringRef("-L") + *i));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003695 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3696 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnallc7363772010-08-15 22:58:12 +00003697 Args.AddAllArgs(CmdArgs, options::OPT_s);
3698 Args.AddAllArgs(CmdArgs, options::OPT_t);
3699 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3700 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003701
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003702 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003703
3704 if (!Args.hasArg(options::OPT_nostdlib) &&
3705 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar20022632010-02-17 08:07:51 +00003706 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00003707 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divackyc16bb762011-02-10 16:59:40 +00003708 if (Args.hasArg(options::OPT_pg))
3709 CmdArgs.push_back("-lm_p");
3710 else
3711 CmdArgs.push_back("-lm");
Daniel Dunbar20022632010-02-17 08:07:51 +00003712 }
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003713 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3714 // the default system libraries. Just mimic this for now.
Roman Divackyc16bb762011-02-10 16:59:40 +00003715 if (Args.hasArg(options::OPT_pg))
3716 CmdArgs.push_back("-lgcc_p");
3717 else
3718 CmdArgs.push_back("-lgcc");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003719 if (Args.hasArg(options::OPT_static)) {
3720 CmdArgs.push_back("-lgcc_eh");
Roman Divackyc16bb762011-02-10 16:59:40 +00003721 } else if (Args.hasArg(options::OPT_pg)) {
3722 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003723 } else {
3724 CmdArgs.push_back("--as-needed");
3725 CmdArgs.push_back("-lgcc_s");
3726 CmdArgs.push_back("--no-as-needed");
3727 }
3728
Matt Beaumont-Gay24230262011-02-10 20:35:01 +00003729 if (Args.hasArg(options::OPT_pthread)) {
Roman Divackyc16bb762011-02-10 16:59:40 +00003730 if (Args.hasArg(options::OPT_pg))
3731 CmdArgs.push_back("-lpthread_p");
3732 else
3733 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay24230262011-02-10 20:35:01 +00003734 }
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003735
Roman Divackyc16bb762011-02-10 16:59:40 +00003736 if (Args.hasArg(options::OPT_pg)) {
3737 if (Args.hasArg(options::OPT_shared))
3738 CmdArgs.push_back("-lc");
3739 else
3740 CmdArgs.push_back("-lc_p");
3741 CmdArgs.push_back("-lgcc_p");
3742 } else {
3743 CmdArgs.push_back("-lc");
3744 CmdArgs.push_back("-lgcc");
3745 }
3746
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003747 if (Args.hasArg(options::OPT_static)) {
3748 CmdArgs.push_back("-lgcc_eh");
Roman Divackyc16bb762011-02-10 16:59:40 +00003749 } else if (Args.hasArg(options::OPT_pg)) {
3750 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003751 } else {
3752 CmdArgs.push_back("--as-needed");
3753 CmdArgs.push_back("-lgcc_s");
3754 CmdArgs.push_back("--no-as-needed");
3755 }
3756 }
3757
3758 if (!Args.hasArg(options::OPT_nostdlib) &&
3759 !Args.hasArg(options::OPT_nostartfiles)) {
3760 if (!Args.hasArg(options::OPT_shared))
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003761 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00003762 "crtend.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003763 else
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003764 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00003765 "crtendS.o")));
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003766 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00003767 "crtn.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003768 }
3769
Bill Wendling3f4be6f2011-06-27 19:15:03 +00003770 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00003771
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003772 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003773 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003774 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003775}
Daniel Dunbar11e1b402009-05-02 18:28:39 +00003776
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003777void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3778 const InputInfo &Output,
3779 const InputInfoList &Inputs,
3780 const ArgList &Args,
3781 const char *LinkingOutput) const {
3782 ArgStringList CmdArgs;
3783
3784 // When building 32-bit code on NetBSD/amd64, we have to explicitly
3785 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00003786 if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
3787 getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003788 CmdArgs.push_back("--32");
3789
3790
3791 // Set byte order explicitly
3792 if (getToolChain().getArchName() == "mips")
3793 CmdArgs.push_back("-EB");
3794 else if (getToolChain().getArchName() == "mipsel")
3795 CmdArgs.push_back("-EL");
3796
3797 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3798 options::OPT_Xassembler);
3799
3800 CmdArgs.push_back("-o");
3801 CmdArgs.push_back(Output.getFilename());
3802
3803 for (InputInfoList::const_iterator
3804 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3805 const InputInfo &II = *it;
3806 CmdArgs.push_back(II.getFilename());
3807 }
3808
Joerg Sonnenberger10c64352011-03-21 14:01:40 +00003809 const char *Exec = Args.MakeArgString(FindTargetProgramPath(getToolChain(),
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00003810 ToolTriple.getTriple(),
3811 "as"));
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003812 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3813}
3814
3815void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3816 const InputInfo &Output,
3817 const InputInfoList &Inputs,
3818 const ArgList &Args,
3819 const char *LinkingOutput) const {
3820 const Driver &D = getToolChain().getDriver();
3821 ArgStringList CmdArgs;
3822
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00003823 if (!D.SysRoot.empty())
3824 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
3825
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003826 if (Args.hasArg(options::OPT_static)) {
3827 CmdArgs.push_back("-Bstatic");
3828 } else {
3829 if (Args.hasArg(options::OPT_rdynamic))
3830 CmdArgs.push_back("-export-dynamic");
3831 CmdArgs.push_back("--eh-frame-hdr");
3832 if (Args.hasArg(options::OPT_shared)) {
3833 CmdArgs.push_back("-Bshareable");
3834 } else {
3835 CmdArgs.push_back("-dynamic-linker");
3836 CmdArgs.push_back("/libexec/ld.elf_so");
3837 }
3838 }
3839
3840 // When building 32-bit code on NetBSD/amd64, we have to explicitly
3841 // instruct ld in the base system to link 32-bit code.
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00003842 if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
3843 getToolChain().getArch() == llvm::Triple::x86) {
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003844 CmdArgs.push_back("-m");
3845 CmdArgs.push_back("elf_i386");
3846 }
3847
3848 if (Output.isFilename()) {
3849 CmdArgs.push_back("-o");
3850 CmdArgs.push_back(Output.getFilename());
3851 } else {
3852 assert(Output.isNothing() && "Invalid output.");
3853 }
3854
3855 if (!Args.hasArg(options::OPT_nostdlib) &&
3856 !Args.hasArg(options::OPT_nostartfiles)) {
3857 if (!Args.hasArg(options::OPT_shared)) {
3858 CmdArgs.push_back(Args.MakeArgString(
3859 getToolChain().GetFilePath("crt0.o")));
3860 CmdArgs.push_back(Args.MakeArgString(
3861 getToolChain().GetFilePath("crti.o")));
3862 CmdArgs.push_back(Args.MakeArgString(
3863 getToolChain().GetFilePath("crtbegin.o")));
3864 } else {
3865 CmdArgs.push_back(Args.MakeArgString(
3866 getToolChain().GetFilePath("crti.o")));
3867 CmdArgs.push_back(Args.MakeArgString(
3868 getToolChain().GetFilePath("crtbeginS.o")));
3869 }
3870 }
3871
3872 Args.AddAllArgs(CmdArgs, options::OPT_L);
3873 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3874 Args.AddAllArgs(CmdArgs, options::OPT_e);
3875 Args.AddAllArgs(CmdArgs, options::OPT_s);
3876 Args.AddAllArgs(CmdArgs, options::OPT_t);
3877 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3878 Args.AddAllArgs(CmdArgs, options::OPT_r);
3879
3880 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3881
3882 if (!Args.hasArg(options::OPT_nostdlib) &&
3883 !Args.hasArg(options::OPT_nodefaultlibs)) {
3884 if (D.CCCIsCXX) {
3885 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3886 CmdArgs.push_back("-lm");
3887 }
3888 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3889 // the default system libraries. Just mimic this for now.
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003890 if (Args.hasArg(options::OPT_static)) {
3891 CmdArgs.push_back("-lgcc_eh");
3892 } else {
3893 CmdArgs.push_back("--as-needed");
3894 CmdArgs.push_back("-lgcc_s");
3895 CmdArgs.push_back("--no-as-needed");
3896 }
Joerg Sonnenbergerdb6393f2011-06-07 23:39:17 +00003897 CmdArgs.push_back("-lgcc");
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003898
3899 if (Args.hasArg(options::OPT_pthread))
3900 CmdArgs.push_back("-lpthread");
3901 CmdArgs.push_back("-lc");
3902
3903 CmdArgs.push_back("-lgcc");
3904 if (Args.hasArg(options::OPT_static)) {
3905 CmdArgs.push_back("-lgcc_eh");
3906 } else {
3907 CmdArgs.push_back("--as-needed");
3908 CmdArgs.push_back("-lgcc_s");
3909 CmdArgs.push_back("--no-as-needed");
3910 }
3911 }
3912
3913 if (!Args.hasArg(options::OPT_nostdlib) &&
3914 !Args.hasArg(options::OPT_nostartfiles)) {
3915 if (!Args.hasArg(options::OPT_shared))
3916 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
3917 "crtend.o")));
3918 else
3919 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
3920 "crtendS.o")));
3921 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
3922 "crtn.o")));
3923 }
3924
Bill Wendling3f4be6f2011-06-27 19:15:03 +00003925 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00003926
Joerg Sonnenberger10c64352011-03-21 14:01:40 +00003927 const char *Exec = Args.MakeArgString(FindTargetProgramPath(getToolChain(),
Joerg Sonnenberger182564c2011-05-16 13:35:02 +00003928 ToolTriple.getTriple(),
3929 "ld"));
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003930 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3931}
3932
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00003933void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3934 const InputInfo &Output,
3935 const InputInfoList &Inputs,
3936 const ArgList &Args,
3937 const char *LinkingOutput) const {
3938 ArgStringList CmdArgs;
3939
3940 // Add --32/--64 to make sure we get the format we want.
3941 // This is incomplete
3942 if (getToolChain().getArch() == llvm::Triple::x86) {
3943 CmdArgs.push_back("--32");
3944 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
3945 CmdArgs.push_back("--64");
3946 } else if (getToolChain().getArch() == llvm::Triple::arm) {
3947 llvm::StringRef MArch = getToolChain().getArchName();
3948 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
3949 CmdArgs.push_back("-mfpu=neon");
3950 }
3951
3952 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3953 options::OPT_Xassembler);
3954
3955 CmdArgs.push_back("-o");
3956 CmdArgs.push_back(Output.getFilename());
3957
3958 for (InputInfoList::const_iterator
3959 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3960 const InputInfo &II = *it;
3961 CmdArgs.push_back(II.getFilename());
3962 }
3963
3964 const char *Exec =
3965 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3966 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3967}
3968
Rafael Espindolac1da9812010-11-07 20:14:31 +00003969void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
3970 const InputInfo &Output,
3971 const InputInfoList &Inputs,
3972 const ArgList &Args,
3973 const char *LinkingOutput) const {
3974 const toolchains::Linux& ToolChain =
3975 static_cast<const toolchains::Linux&>(getToolChain());
3976 const Driver &D = ToolChain.getDriver();
3977 ArgStringList CmdArgs;
3978
Rafael Espindola26f14c32010-11-15 18:28:16 +00003979 // Silence warning for "clang -g foo.o -o foo"
3980 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00003981 // and "clang -emit-llvm foo.o -o foo"
3982 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindola7f6458b2010-11-17 20:37:10 +00003983 // and for "clang -g foo.o -o foo". Other warning options are already
3984 // handled somewhere else.
3985 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindola26f14c32010-11-15 18:28:16 +00003986
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00003987 if (!D.SysRoot.empty())
3988 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac1da9812010-11-07 20:14:31 +00003989
Rafael Espindolafdda1712010-11-17 22:26:15 +00003990 if (Args.hasArg(options::OPT_pie))
3991 CmdArgs.push_back("-pie");
3992
Rafael Espindoladc1b76d2010-11-07 22:57:16 +00003993 if (Args.hasArg(options::OPT_rdynamic))
3994 CmdArgs.push_back("-export-dynamic");
3995
Rafael Espindolae0e6d3b2010-11-11 19:34:42 +00003996 if (Args.hasArg(options::OPT_s))
3997 CmdArgs.push_back("-s");
3998
Rafael Espindolac1da9812010-11-07 20:14:31 +00003999 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4000 e = ToolChain.ExtraOpts.end();
4001 i != e; ++i)
4002 CmdArgs.push_back(i->c_str());
4003
4004 if (!Args.hasArg(options::OPT_static)) {
4005 CmdArgs.push_back("--eh-frame-hdr");
4006 }
4007
4008 CmdArgs.push_back("-m");
4009 if (ToolChain.getArch() == llvm::Triple::x86)
4010 CmdArgs.push_back("elf_i386");
Douglas Gregorf0594d82011-03-06 19:11:49 +00004011 else if (ToolChain.getArch() == llvm::Triple::arm
4012 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00004013 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43ac2972011-04-05 22:04:27 +00004014 else if (ToolChain.getArch() == llvm::Triple::ppc)
4015 CmdArgs.push_back("elf32ppclinux");
4016 else if (ToolChain.getArch() == llvm::Triple::ppc64)
4017 CmdArgs.push_back("elf64ppc");
Rafael Espindolac1da9812010-11-07 20:14:31 +00004018 else
4019 CmdArgs.push_back("elf_x86_64");
4020
4021 if (Args.hasArg(options::OPT_static)) {
Douglas Gregorf0594d82011-03-06 19:11:49 +00004022 if (ToolChain.getArch() == llvm::Triple::arm
4023 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00004024 CmdArgs.push_back("-Bstatic");
4025 else
4026 CmdArgs.push_back("-static");
4027 } else if (Args.hasArg(options::OPT_shared)) {
4028 CmdArgs.push_back("-shared");
4029 }
4030
4031 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregorf0594d82011-03-06 19:11:49 +00004032 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac1da9812010-11-07 20:14:31 +00004033 (!Args.hasArg(options::OPT_static) &&
4034 !Args.hasArg(options::OPT_shared))) {
4035 CmdArgs.push_back("-dynamic-linker");
4036 if (ToolChain.getArch() == llvm::Triple::x86)
4037 CmdArgs.push_back("/lib/ld-linux.so.2");
Douglas Gregorf0594d82011-03-06 19:11:49 +00004038 else if (ToolChain.getArch() == llvm::Triple::arm ||
4039 ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00004040 CmdArgs.push_back("/lib/ld-linux.so.3");
Ted Kremenek43ac2972011-04-05 22:04:27 +00004041 else if (ToolChain.getArch() == llvm::Triple::ppc)
Chris Lattner09f43ed2011-04-11 21:15:37 +00004042 CmdArgs.push_back("/lib/ld.so.1");
Ted Kremenek43ac2972011-04-05 22:04:27 +00004043 else if (ToolChain.getArch() == llvm::Triple::ppc64)
Chris Lattner09f43ed2011-04-11 21:15:37 +00004044 CmdArgs.push_back("/lib64/ld64.so.1");
Rafael Espindolac1da9812010-11-07 20:14:31 +00004045 else
4046 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
4047 }
4048
4049 CmdArgs.push_back("-o");
4050 CmdArgs.push_back(Output.getFilename());
4051
Rafael Espindola49c64fd2010-12-01 01:52:43 +00004052 if (!Args.hasArg(options::OPT_nostdlib) &&
4053 !Args.hasArg(options::OPT_nostartfiles)) {
Rafael Espindolafdda1712010-11-17 22:26:15 +00004054 const char *crt1 = NULL;
4055 if (!Args.hasArg(options::OPT_shared)){
4056 if (Args.hasArg(options::OPT_pie))
4057 crt1 = "Scrt1.o";
4058 else
4059 crt1 = "crt1.o";
4060 }
4061 if (crt1)
4062 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac1da9812010-11-07 20:14:31 +00004063
Rafael Espindola89414b32010-11-12 03:00:39 +00004064 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
Rafael Espindolac1da9812010-11-07 20:14:31 +00004065
Rafael Espindola89414b32010-11-12 03:00:39 +00004066 const char *crtbegin;
4067 if (Args.hasArg(options::OPT_static))
4068 crtbegin = "crtbeginT.o";
Rafael Espindolafdda1712010-11-17 22:26:15 +00004069 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Rafael Espindola89414b32010-11-12 03:00:39 +00004070 crtbegin = "crtbeginS.o";
4071 else
4072 crtbegin = "crtbegin.o";
4073 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
4074 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00004075
4076 Args.AddAllArgs(CmdArgs, options::OPT_L);
4077
4078 const ToolChain::path_list Paths = ToolChain.getFilePaths();
4079
Roman Divacky58e5ac92011-03-01 17:53:14 +00004080 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
4081 i != e; ++i)
4082 CmdArgs.push_back(Args.MakeArgString(llvm::StringRef("-L") + *i));
Rafael Espindolac1da9812010-11-07 20:14:31 +00004083
4084 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4085
Rafael Espindola89414b32010-11-12 03:00:39 +00004086 if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) {
Rafael Espindolac1da9812010-11-07 20:14:31 +00004087 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4088 CmdArgs.push_back("-lm");
4089 }
4090
Rafael Espindola89414b32010-11-12 03:00:39 +00004091 if (!Args.hasArg(options::OPT_nostdlib)) {
Nick Lewycky80df0252011-06-04 06:27:06 +00004092 if (Args.hasArg(options::OPT_static))
4093 CmdArgs.push_back("--start-group");
4094
Rafael Espindola89414b32010-11-12 03:00:39 +00004095 if (!D.CCCIsCXX)
Rafael Espindolac1da9812010-11-07 20:14:31 +00004096 CmdArgs.push_back("-lgcc");
Rafael Espindola89414b32010-11-12 03:00:39 +00004097
4098 if (Args.hasArg(options::OPT_static)) {
4099 if (D.CCCIsCXX)
4100 CmdArgs.push_back("-lgcc");
4101 } else {
4102 if (!D.CCCIsCXX)
4103 CmdArgs.push_back("--as-needed");
4104 CmdArgs.push_back("-lgcc_s");
4105 if (!D.CCCIsCXX)
4106 CmdArgs.push_back("--no-as-needed");
4107 }
4108
4109 if (Args.hasArg(options::OPT_static))
4110 CmdArgs.push_back("-lgcc_eh");
4111 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
4112 CmdArgs.push_back("-lgcc");
4113
4114 if (Args.hasArg(options::OPT_pthread) ||
4115 Args.hasArg(options::OPT_pthreads))
4116 CmdArgs.push_back("-lpthread");
4117
4118 CmdArgs.push_back("-lc");
4119
4120 if (Args.hasArg(options::OPT_static))
4121 CmdArgs.push_back("--end-group");
4122 else {
4123 if (!D.CCCIsCXX)
4124 CmdArgs.push_back("-lgcc");
4125
4126 if (!D.CCCIsCXX)
4127 CmdArgs.push_back("--as-needed");
4128 CmdArgs.push_back("-lgcc_s");
4129 if (!D.CCCIsCXX)
4130 CmdArgs.push_back("--no-as-needed");
4131
4132 if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
4133 CmdArgs.push_back("-lgcc");
4134 }
4135
Rafael Espindolafdda1712010-11-17 22:26:15 +00004136
Rafael Espindola49c64fd2010-12-01 01:52:43 +00004137 if (!Args.hasArg(options::OPT_nostartfiles)) {
4138 const char *crtend;
4139 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
4140 crtend = "crtendS.o";
4141 else
4142 crtend = "crtend.o";
Rafael Espindola89414b32010-11-12 03:00:39 +00004143
Rafael Espindola49c64fd2010-12-01 01:52:43 +00004144 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
4145 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
4146 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00004147 }
4148
Bill Wendling3f4be6f2011-06-27 19:15:03 +00004149 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00004150
Rafael Espindolac1da9812010-11-07 20:14:31 +00004151 if (Args.hasArg(options::OPT_use_gold_plugin)) {
4152 CmdArgs.push_back("-plugin");
4153 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
4154 CmdArgs.push_back(Args.MakeArgString(Plugin));
4155 }
4156
4157 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
4158}
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00004159
Chris Lattner38e317d2010-07-07 16:01:42 +00004160void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004161 const InputInfo &Output,
4162 const InputInfoList &Inputs,
4163 const ArgList &Args,
4164 const char *LinkingOutput) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00004165 ArgStringList CmdArgs;
4166
4167 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4168 options::OPT_Xassembler);
4169
4170 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004171 CmdArgs.push_back(Output.getFilename());
Chris Lattner38e317d2010-07-07 16:01:42 +00004172
4173 for (InputInfoList::const_iterator
4174 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4175 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004176 CmdArgs.push_back(II.getFilename());
Chris Lattner38e317d2010-07-07 16:01:42 +00004177 }
4178
4179 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004180 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004181 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner38e317d2010-07-07 16:01:42 +00004182}
4183
4184void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004185 const InputInfo &Output,
4186 const InputInfoList &Inputs,
4187 const ArgList &Args,
4188 const char *LinkingOutput) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00004189 const Driver &D = getToolChain().getDriver();
4190 ArgStringList CmdArgs;
4191
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004192 if (Output.isFilename()) {
Chris Lattner38e317d2010-07-07 16:01:42 +00004193 CmdArgs.push_back("-o");
4194 CmdArgs.push_back(Output.getFilename());
4195 } else {
4196 assert(Output.isNothing() && "Invalid output.");
4197 }
4198
4199 if (!Args.hasArg(options::OPT_nostdlib) &&
4200 !Args.hasArg(options::OPT_nostartfiles))
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004201 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00004202 "/usr/gnu/lib/crtso.o")));
4203
4204 Args.AddAllArgs(CmdArgs, options::OPT_L);
4205 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4206 Args.AddAllArgs(CmdArgs, options::OPT_e);
4207
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004208 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner38e317d2010-07-07 16:01:42 +00004209
4210 if (!Args.hasArg(options::OPT_nostdlib) &&
4211 !Args.hasArg(options::OPT_nodefaultlibs)) {
4212 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00004213 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner38e317d2010-07-07 16:01:42 +00004214 CmdArgs.push_back("-lm");
4215 }
4216
4217 if (Args.hasArg(options::OPT_pthread))
4218 CmdArgs.push_back("-lpthread");
4219 CmdArgs.push_back("-lc");
4220 CmdArgs.push_back("-lgcc");
4221 CmdArgs.push_back("-L/usr/gnu/lib");
4222 // FIXME: fill in the correct search path for the final
4223 // support libraries.
4224 CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
4225 }
4226
4227 if (!Args.hasArg(options::OPT_nostdlib) &&
4228 !Args.hasArg(options::OPT_nostartfiles)) {
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004229 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00004230 "/usr/gnu/lib/libend.a")));
4231 }
4232
Bill Wendling3f4be6f2011-06-27 19:15:03 +00004233 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00004234
Chris Lattner38e317d2010-07-07 16:01:42 +00004235 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004236 Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004237 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner38e317d2010-07-07 16:01:42 +00004238}
4239
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004240/// DragonFly Tools
4241
4242// For now, DragonFly Assemble does just about the same as for
4243// FreeBSD, but this may change soon.
4244void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004245 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00004246 const InputInfoList &Inputs,
4247 const ArgList &Args,
4248 const char *LinkingOutput) const {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004249 ArgStringList CmdArgs;
4250
4251 // When building 32-bit code on DragonFly/pc64, we have to explicitly
4252 // instruct as in the base system to assemble 32-bit code.
4253 if (getToolChain().getArchName() == "i386")
4254 CmdArgs.push_back("--32");
4255
4256 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4257 options::OPT_Xassembler);
4258
4259 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004260 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004261
4262 for (InputInfoList::const_iterator
4263 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4264 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004265 CmdArgs.push_back(II.getFilename());
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004266 }
4267
4268 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004269 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004270 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004271}
4272
4273void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004274 const InputInfo &Output,
4275 const InputInfoList &Inputs,
4276 const ArgList &Args,
4277 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00004278 const Driver &D = getToolChain().getDriver();
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004279 ArgStringList CmdArgs;
4280
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00004281 if (!D.SysRoot.empty())
4282 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4283
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004284 if (Args.hasArg(options::OPT_static)) {
4285 CmdArgs.push_back("-Bstatic");
4286 } else {
4287 if (Args.hasArg(options::OPT_shared))
4288 CmdArgs.push_back("-Bshareable");
4289 else {
4290 CmdArgs.push_back("-dynamic-linker");
4291 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
4292 }
4293 }
4294
4295 // When building 32-bit code on DragonFly/pc64, we have to explicitly
4296 // instruct ld in the base system to link 32-bit code.
4297 if (getToolChain().getArchName() == "i386") {
4298 CmdArgs.push_back("-m");
4299 CmdArgs.push_back("elf_i386");
4300 }
4301
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004302 if (Output.isFilename()) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004303 CmdArgs.push_back("-o");
4304 CmdArgs.push_back(Output.getFilename());
4305 } else {
4306 assert(Output.isNothing() && "Invalid output.");
4307 }
4308
4309 if (!Args.hasArg(options::OPT_nostdlib) &&
4310 !Args.hasArg(options::OPT_nostartfiles)) {
4311 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00004312 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004313 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004314 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004315 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004316 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004317 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004318 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00004319 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004320 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004321 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004322 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004323 }
4324 }
4325
4326 Args.AddAllArgs(CmdArgs, options::OPT_L);
4327 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4328 Args.AddAllArgs(CmdArgs, options::OPT_e);
4329
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004330 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004331
4332 if (!Args.hasArg(options::OPT_nostdlib) &&
4333 !Args.hasArg(options::OPT_nodefaultlibs)) {
4334 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
4335 // rpaths
4336 CmdArgs.push_back("-L/usr/lib/gcc41");
4337
4338 if (!Args.hasArg(options::OPT_static)) {
4339 CmdArgs.push_back("-rpath");
4340 CmdArgs.push_back("/usr/lib/gcc41");
4341
4342 CmdArgs.push_back("-rpath-link");
4343 CmdArgs.push_back("/usr/lib/gcc41");
4344
4345 CmdArgs.push_back("-rpath");
4346 CmdArgs.push_back("/usr/lib");
4347
4348 CmdArgs.push_back("-rpath-link");
4349 CmdArgs.push_back("/usr/lib");
4350 }
4351
Rafael Espindola405861d2010-07-20 12:59:03 +00004352 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00004353 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola405861d2010-07-20 12:59:03 +00004354 CmdArgs.push_back("-lm");
4355 }
4356
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004357 if (Args.hasArg(options::OPT_shared)) {
4358 CmdArgs.push_back("-lgcc_pic");
4359 } else {
4360 CmdArgs.push_back("-lgcc");
4361 }
4362
4363
4364 if (Args.hasArg(options::OPT_pthread))
Mike Stump4d63f8b2009-10-31 20:11:46 +00004365 CmdArgs.push_back("-lpthread");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004366
4367 if (!Args.hasArg(options::OPT_nolibc)) {
4368 CmdArgs.push_back("-lc");
4369 }
4370
4371 if (Args.hasArg(options::OPT_shared)) {
4372 CmdArgs.push_back("-lgcc_pic");
4373 } else {
4374 CmdArgs.push_back("-lgcc");
4375 }
4376 }
4377
4378 if (!Args.hasArg(options::OPT_nostdlib) &&
4379 !Args.hasArg(options::OPT_nostartfiles)) {
4380 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00004381 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004382 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004383 else
Chris Lattner38e317d2010-07-07 16:01:42 +00004384 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004385 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004386 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004387 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004388 }
4389
Bill Wendling3f4be6f2011-06-27 19:15:03 +00004390 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00004391
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004392 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004393 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004394 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004395}
Michael J. Spencerff58e362010-08-21 21:55:07 +00004396
4397void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
4398 const InputInfo &Output,
4399 const InputInfoList &Inputs,
4400 const ArgList &Args,
4401 const char *LinkingOutput) const {
Michael J. Spencerff58e362010-08-21 21:55:07 +00004402 ArgStringList CmdArgs;
4403
4404 if (Output.isFilename()) {
Daniel Dunbare5a37f42010-09-17 00:45:02 +00004405 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
4406 Output.getFilename()));
Michael J. Spencerff58e362010-08-21 21:55:07 +00004407 } else {
4408 assert(Output.isNothing() && "Invalid output.");
4409 }
4410
4411 if (!Args.hasArg(options::OPT_nostdlib) &&
4412 !Args.hasArg(options::OPT_nostartfiles)) {
4413 CmdArgs.push_back("-defaultlib:libcmt");
4414 }
4415
4416 CmdArgs.push_back("-nologo");
4417
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004418 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Michael J. Spencerff58e362010-08-21 21:55:07 +00004419
4420 const char *Exec =
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004421 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerff58e362010-08-21 21:55:07 +00004422 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4423}