blob: a8998c49a7028d5f979da7fda07874aec0356559 [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"
20#include "clang/Driver/Option.h"
Daniel Dunbar265e9ef2009-11-19 04:25:22 +000021#include "clang/Driver/Options.h"
Daniel Dunbarb488c1d2009-03-18 08:07:30 +000022#include "clang/Driver/ToolChain.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000023#include "clang/Driver/Util.h"
24
Daniel Dunbar88137642009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Douglas Gregor55d3f7a2009-10-29 00:41:01 +000026#include "llvm/ADT/StringSwitch.h"
Daniel Dunbar5b750fe2009-09-09 22:32:34 +000027#include "llvm/ADT/Twine.h"
Michael J. Spencer32bef4e2011-01-10 02:34:13 +000028#include "llvm/Support/FileSystem.h"
Daniel Dunbar02633b52009-03-26 16:23:12 +000029#include "llvm/Support/Format.h"
30#include "llvm/Support/raw_ostream.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000031#include "llvm/Support/Host.h"
32#include "llvm/Support/Process.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000033
34#include "InputInfo.h"
Daniel Dunbar02633b52009-03-26 16:23:12 +000035#include "ToolChains.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000036
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +000037#ifdef __CYGWIN__
38#include <cygwin/version.h>
39#if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
40#define IS_CYGWIN15 1
41#endif
42#endif
43
Daniel Dunbar47ac7d22009-03-18 06:00:36 +000044using namespace clang::driver;
45using namespace clang::driver::tools;
46
Joerg Sonnenberger10c64352011-03-21 14:01:40 +000047/// FindTargetProgramPath - Return path of the target specific version of
48/// ProgName. If it doesn't exist, return path of ProgName itself.
49static std::string FindTargetProgramPath(const ToolChain &TheToolChain,
50 const char *ProgName) {
51 std::string Executable(TheToolChain.getTripleString() + "-" + ProgName);
52 std::string Path(TheToolChain.GetProgramPath(Executable.c_str()));
53 if (Path != Executable)
54 return Path;
55 return TheToolChain.GetProgramPath(ProgName);
56}
57
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +000058/// CheckPreprocessingOptions - Perform some validation of preprocessing
59/// arguments that is shared with gcc.
60static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
61 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Joerg Sonnenberger9ade4ae2011-03-06 23:31:01 +000062 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +000063 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
64 << A->getAsString(Args) << "-E";
65}
66
Daniel Dunbare2fd6642009-09-10 01:21:12 +000067/// CheckCodeGenerationOptions - Perform some validation of code generation
68/// arguments that is shared with gcc.
69static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
70 // In gcc, only ARM checks this, but it seems reasonable to check universally.
71 if (Args.hasArg(options::OPT_static))
72 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
73 options::OPT_mdynamic_no_pic))
74 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
75 << A->getAsString(Args) << "-static";
76}
77
Chris Lattner3edbeb72010-03-29 17:55:58 +000078// Quote target names for inclusion in GNU Make dependency files.
79// Only the characters '$', '#', ' ', '\t' are quoted.
80static void QuoteTarget(llvm::StringRef Target,
81 llvm::SmallVectorImpl<char> &Res) {
82 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
83 switch (Target[i]) {
84 case ' ':
85 case '\t':
86 // Escape the preceding backslashes
87 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
88 Res.push_back('\\');
89
90 // Escape the space/tab
91 Res.push_back('\\');
92 break;
93 case '$':
94 Res.push_back('$');
95 break;
96 case '#':
97 Res.push_back('\\');
98 break;
99 default:
100 break;
101 }
102
103 Res.push_back(Target[i]);
104 }
105}
106
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000107static void AddLinkerInputs(const ToolChain &TC,
108 const InputInfoList &Inputs, const ArgList &Args,
109 ArgStringList &CmdArgs) {
110 const Driver &D = TC.getDriver();
111
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000112 // Add extra linker input arguments which are not treated as inputs
113 // (constructed via -Xarch_).
114 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
115
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000116 for (InputInfoList::const_iterator
117 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
118 const InputInfo &II = *it;
119
120 if (!TC.HasNativeLLVMSupport()) {
121 // Don't try to pass LLVM inputs unless we have native support.
122 if (II.getType() == types::TY_LLVM_IR ||
123 II.getType() == types::TY_LTO_IR ||
124 II.getType() == types::TY_LLVM_BC ||
125 II.getType() == types::TY_LTO_BC)
126 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
127 << TC.getTripleString();
128 }
129
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000130 // Add filenames immediately.
131 if (II.isFilename()) {
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000132 CmdArgs.push_back(II.getFilename());
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000133 continue;
134 }
135
136 // Otherwise, this is a linker input argument.
137 const Arg &A = II.getInputArg();
138
139 // Handle reserved library options.
140 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000141 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Sen7433fed2010-09-17 18:39:08 +0000142 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
143 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000144 } else
145 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000146 }
147}
148
Mike Stump1eb44332009-09-09 15:08:12 +0000149void Clang::AddPreprocessingOptions(const Driver &D,
Douglas Gregordf91ef32009-04-18 00:34:01 +0000150 const ArgList &Args,
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000151 ArgStringList &CmdArgs,
152 const InputInfo &Output,
153 const InputInfoList &Inputs) const {
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000154 Arg *A;
Daniel Dunbar3a183d32009-06-08 21:48:20 +0000155
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +0000156 CheckPreprocessingOptions(D, Args);
157
158 Args.AddLastArg(CmdArgs, options::OPT_C);
159 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar3a183d32009-06-08 21:48:20 +0000160
161 // Handle dependency file generation.
Daniel Dunbar9eb93b02010-12-08 21:33:40 +0000162 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000163 (A = Args.getLastArg(options::OPT_MD)) ||
164 (A = Args.getLastArg(options::OPT_MMD))) {
165 // Determine the output location.
166 const char *DepFile;
167 if (Output.getType() == types::TY_Dependencies) {
Daniel Dunbar7c1e4652010-08-02 02:38:21 +0000168 DepFile = Output.getFilename();
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000169 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
170 DepFile = MF->getValue(Args);
Daniel Dunbarb827a052009-11-19 03:26:40 +0000171 } else if (A->getOption().matches(options::OPT_M) ||
172 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000173 DepFile = "-";
174 } else {
175 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
176 }
177 CmdArgs.push_back("-dependency-file");
178 CmdArgs.push_back(DepFile);
179
Chris Lattner3edbeb72010-03-29 17:55:58 +0000180 // Add a default target if one wasn't specified.
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000181 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
182 const char *DepTarget;
183
184 // If user provided -o, that is the dependency target, except
185 // when we are only generating a dependency file.
186 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
187 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
188 DepTarget = OutputOpt->getValue(Args);
189 } else {
190 // Otherwise derive from the base input.
191 //
192 // FIXME: This should use the computed output file location.
Michael J. Spencer472ccff2010-12-18 00:19:12 +0000193 llvm::SmallString<128> P(Inputs[0].getBaseInput());
194 llvm::sys::path::replace_extension(P, "o");
195 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000196 }
197
198 CmdArgs.push_back("-MT");
Chris Lattner3edbeb72010-03-29 17:55:58 +0000199 llvm::SmallString<128> Quoted;
200 QuoteTarget(DepTarget, Quoted);
201 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000202 }
203
Daniel Dunbarb827a052009-11-19 03:26:40 +0000204 if (A->getOption().matches(options::OPT_M) ||
205 A->getOption().matches(options::OPT_MD))
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000206 CmdArgs.push_back("-sys-header-deps");
207 }
208
209 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000210
211 // Convert all -MQ <target> args to -MT <quoted target>
212 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
213 options::OPT_MQ),
214 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000215 const Arg *A = *it;
216 A->claim();
Chris Lattner3edbeb72010-03-29 17:55:58 +0000217
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000218 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattner3edbeb72010-03-29 17:55:58 +0000219 CmdArgs.push_back("-MT");
220 llvm::SmallString<128> Quoted;
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000221 QuoteTarget(A->getValue(Args), Quoted);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000222 CmdArgs.push_back(Args.MakeArgString(Quoted));
223
224 // -MT flag - no change
225 } else {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000226 A->render(Args, CmdArgs);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000227 }
228 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000229
Douglas Gregordf91ef32009-04-18 00:34:01 +0000230 // Add -i* options, and automatically translate to
231 // -include-pch/-include-pth for transparent PCH support. It's
232 // wonky, but we include looking for .gch so we can support seamless
233 // replacement into a build system already set up to be generating
234 // .gch files.
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000235 bool RenderedImplicitInclude = false;
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000236 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
237 ie = Args.filtered_end(); it != ie; ++it) {
238 const Arg *A = it;
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000239
240 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000241 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
242 RenderedImplicitInclude = true;
243
Argyrios Kyrtzidise5c35372010-08-11 23:27:58 +0000244 // Use PCH if the user requested it.
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000245 bool UsePCH = D.CCCUsePCH;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000246
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000247 bool FoundPTH = false;
Douglas Gregordf91ef32009-04-18 00:34:01 +0000248 bool FoundPCH = false;
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000249 llvm::sys::Path P(A->getValue(Args));
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000250 bool Exists;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000251 if (UsePCH) {
Douglas Gregordf91ef32009-04-18 00:34:01 +0000252 P.appendSuffix("pch");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000253 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregordf91ef32009-04-18 00:34:01 +0000254 FoundPCH = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000255 else
Douglas Gregordf91ef32009-04-18 00:34:01 +0000256 P.eraseSuffix();
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000257 }
258
Douglas Gregordf91ef32009-04-18 00:34:01 +0000259 if (!FoundPCH) {
260 P.appendSuffix("pth");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000261 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregordf91ef32009-04-18 00:34:01 +0000262 FoundPTH = true;
263 else
264 P.eraseSuffix();
Mike Stump1eb44332009-09-09 15:08:12 +0000265 }
266
Douglas Gregordf91ef32009-04-18 00:34:01 +0000267 if (!FoundPCH && !FoundPTH) {
268 P.appendSuffix("gch");
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000269 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000270 FoundPCH = UsePCH;
271 FoundPTH = !UsePCH;
Douglas Gregordf91ef32009-04-18 00:34:01 +0000272 }
Mike Stump1eb44332009-09-09 15:08:12 +0000273 else
Douglas Gregordf91ef32009-04-18 00:34:01 +0000274 P.eraseSuffix();
275 }
276
277 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000278 if (IsFirstImplicitInclude) {
279 A->claim();
280 if (UsePCH)
281 CmdArgs.push_back("-include-pch");
282 else
283 CmdArgs.push_back("-include-pth");
284 CmdArgs.push_back(Args.MakeArgString(P.str()));
285 continue;
286 } else {
287 // Ignore the PCH if not first on command line and emit warning.
288 D.Diag(clang::diag::warn_drv_pch_not_first_include)
289 << P.str() << A->getAsString(Args);
290 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000291 }
292 }
293
294 // Not translated, render as usual.
295 A->claim();
296 A->render(Args, CmdArgs);
297 }
298
299 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
300 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
301
Daniel Dunbar641b98b2010-09-14 23:12:35 +0000302 // Add C++ include arguments, if needed.
303 types::ID InputType = Inputs[0].getType();
304 if (types::isCXX(InputType))
305 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
306
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000307 // Add -Wp, and -Xassembler if using the preprocessor.
308
309 // FIXME: There is a very unfortunate problem here, some troubled
310 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
311 // really support that we would have to parse and then translate
312 // those options. :(
313 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
314 options::OPT_Xpreprocessor);
Daniel Dunbar607d7f62009-10-29 01:53:44 +0000315
316 // -I- is a deprecated GCC feature, reject it.
317 if (Arg *A = Args.getLastArg(options::OPT_I_))
318 D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruthfeee58c2010-10-20 07:00:47 +0000319
320 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
321 // -isysroot to the CC1 invocation.
322 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
323 if (!Args.hasArg(options::OPT_isysroot)) {
324 CmdArgs.push_back("-isysroot");
325 CmdArgs.push_back(A->getValue(Args));
326 }
327 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000328}
329
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000330/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Daniel Dunbar728a5122009-09-10 06:49:20 +0000331//
332// FIXME: tblgen this.
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000333static const char *getARMTargetCPU(const ArgList &Args,
334 const llvm::Triple &Triple) {
Daniel Dunbar728a5122009-09-10 06:49:20 +0000335 // FIXME: Warn on inconsistent use of -mcpu and -march.
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000336
337 // If we have -mcpu=, use that.
338 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
339 return A->getValue(Args);
340
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000341 llvm::StringRef MArch;
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000342 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000343 // Otherwise, if we have -march= choose the base CPU for that arch.
344 MArch = A->getValue(Args);
345 } else {
346 // Otherwise, use the Arch from the triple.
347 MArch = Triple.getArchName();
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000348 }
349
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000350 if (MArch == "armv2" || MArch == "armv2a")
351 return "arm2";
352 if (MArch == "armv3")
353 return "arm6";
354 if (MArch == "armv3m")
355 return "arm7m";
356 if (MArch == "armv4" || MArch == "armv4t")
357 return "arm7tdmi";
358 if (MArch == "armv5" || MArch == "armv5t")
359 return "arm10tdmi";
360 if (MArch == "armv5e" || MArch == "armv5te")
361 return "arm1026ejs";
362 if (MArch == "armv5tej")
363 return "arm926ej-s";
364 if (MArch == "armv6" || MArch == "armv6k")
365 return "arm1136jf-s";
366 if (MArch == "armv6j")
367 return "arm1136j-s";
368 if (MArch == "armv6z" || MArch == "armv6zk")
369 return "arm1176jzf-s";
370 if (MArch == "armv6t2")
371 return "arm1156t2-s";
372 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
373 return "cortex-a8";
374 if (MArch == "armv7r" || MArch == "armv7-r")
375 return "cortex-r4";
376 if (MArch == "armv7m" || MArch == "armv7-m")
377 return "cortex-m3";
378 if (MArch == "ep9312")
379 return "ep9312";
380 if (MArch == "iwmmxt")
381 return "iwmmxt";
382 if (MArch == "xscale")
383 return "xscale";
Bob Wilson1ec0ade2011-03-21 20:40:05 +0000384 if (MArch == "armv6m" || MArch == "armv6-m")
385 return "cortex-m0";
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000386
387 // If all else failed, return the most base CPU LLVM supports.
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000388 return "arm7tdmi";
389}
390
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000391/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbar728a5122009-09-10 06:49:20 +0000392/// CPU.
393//
394// FIXME: This is redundant with -mcpu, why does LLVM use this.
395// FIXME: tblgen this, or kill it!
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000396static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) {
Daniel Dunbar728a5122009-09-10 06:49:20 +0000397 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" ||
398 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" ||
399 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" ||
400 CPU == "arm940t" || CPU == "ep9312")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000401 return "v4t";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000402
403 if (CPU == "arm10tdmi" || CPU == "arm1020t")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000404 return "v5";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000405
406 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" ||
407 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" ||
408 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" ||
409 CPU == "iwmmxt")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000410 return "v5e";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000411
412 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" ||
413 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000414 return "v6";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000415
416 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000417 return "v6t2";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000418
419 if (CPU == "cortex-a8" || CPU == "cortex-a9")
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000420 return "v7";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000421
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000422 return "";
Daniel Dunbar728a5122009-09-10 06:49:20 +0000423}
424
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000425// FIXME: Move to target hook.
426static bool isSignedCharDefault(const llvm::Triple &Triple) {
427 switch (Triple.getArch()) {
428 default:
429 return true;
430
431 case llvm::Triple::ppc:
432 case llvm::Triple::ppc64:
433 if (Triple.getOS() == llvm::Triple::Darwin)
434 return true;
435 return false;
436
437 case llvm::Triple::systemz:
438 return false;
439 }
440}
441
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000442void Clang::AddARMTargetArgs(const ArgList &Args,
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000443 ArgStringList &CmdArgs,
444 bool KernelOrKext) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +0000445 const Driver &D = getToolChain().getDriver();
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000446 llvm::Triple Triple = getToolChain().getTriple();
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000447
Daniel Dunbardb04e2e2011-03-02 00:55:57 +0000448 // Disable movt generation, if requested.
449#ifdef DISABLE_ARM_DARWIN_USE_MOVT
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000450 CmdArgs.push_back("-backend-option");
Daniel Dunbardb04e2e2011-03-02 00:55:57 +0000451 CmdArgs.push_back("-arm-darwin-use-movt=0");
452#endif
453
Daniel Dunbar2030d8f2009-09-14 00:34:46 +0000454 // Select the ABI to use.
455 //
456 // FIXME: Support -meabi.
457 const char *ABIName = 0;
458 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
459 ABIName = A->getValue(Args);
460 } else {
461 // Select the default based on the platform.
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000462 switch(Triple.getEnvironment()) {
463 case llvm::Triple::GNUEABI:
Daniel Dunbar2030d8f2009-09-14 00:34:46 +0000464 ABIName = "aapcs-linux";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000465 break;
466 case llvm::Triple::EABI:
Rafael Espindola1ed1a592010-06-16 19:01:17 +0000467 ABIName = "aapcs";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000468 break;
469 default:
Rafael Espindola1ed1a592010-06-16 19:01:17 +0000470 ABIName = "apcs-gnu";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000471 }
Daniel Dunbar2030d8f2009-09-14 00:34:46 +0000472 }
473 CmdArgs.push_back("-target-abi");
474 CmdArgs.push_back(ABIName);
475
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000476 // Set the CPU based on -march= and -mcpu=.
Daniel Dunbar38b48af2009-12-18 06:30:12 +0000477 CmdArgs.push_back("-target-cpu");
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000478 CmdArgs.push_back(getARMTargetCPU(Args, Triple));
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000479
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000480 // Select the float ABI as determined by -msoft-float, -mhard-float, and
481 // -mfloat-abi=.
482 llvm::StringRef FloatABI;
483 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
484 options::OPT_mhard_float,
485 options::OPT_mfloat_abi_EQ)) {
486 if (A->getOption().matches(options::OPT_msoft_float))
487 FloatABI = "soft";
488 else if (A->getOption().matches(options::OPT_mhard_float))
489 FloatABI = "hard";
490 else {
491 FloatABI = A->getValue(Args);
492 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
493 D.Diag(clang::diag::err_drv_invalid_mfloat_abi)
494 << A->getAsString(Args);
495 FloatABI = "soft";
496 }
497 }
498 }
499
500 // If unspecified, choose the default based on the platform.
501 if (FloatABI.empty()) {
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000502 const llvm::Triple &Triple = getToolChain().getTriple();
503 switch (Triple.getOS()) {
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000504 case llvm::Triple::Darwin: {
505 // Darwin defaults to "softfp" for v6 and v7.
506 //
507 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000508 llvm::StringRef ArchName =
509 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000510 if (ArchName.startswith("v6") || ArchName.startswith("v7"))
511 FloatABI = "softfp";
512 else
513 FloatABI = "soft";
514 break;
515 }
516
Rafael Espindola7e9cebf2010-06-27 18:29:21 +0000517 case llvm::Triple::Linux: {
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000518 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) {
Rafael Espindola7e9cebf2010-06-27 18:29:21 +0000519 FloatABI = "softfp";
520 break;
521 }
522 }
523 // fall through
524
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000525 default:
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000526 switch(Triple.getEnvironment()) {
527 case llvm::Triple::GNUEABI:
528 FloatABI = "softfp";
529 break;
530 case llvm::Triple::EABI:
531 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
532 FloatABI = "softfp";
533 break;
534 default:
535 // Assume "soft", but warn the user we are guessing.
536 FloatABI = "soft";
537 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
538 break;
539 }
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000540 }
541 }
542
543 if (FloatABI == "soft") {
544 // Floating point operations and argument passing are soft.
545 //
546 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbar3b315262009-11-30 08:42:00 +0000547 CmdArgs.push_back("-msoft-float");
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000548 CmdArgs.push_back("-mfloat-abi");
549 CmdArgs.push_back("soft");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000550 } else if (FloatABI == "softfp") {
551 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000552 CmdArgs.push_back("-mfloat-abi");
553 CmdArgs.push_back("soft");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000554 } else {
555 // Floating point operations and argument passing are hard.
556 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000557 CmdArgs.push_back("-mfloat-abi");
558 CmdArgs.push_back("hard");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000559 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +0000560
561 // Set appropriate target features for floating point mode.
562 //
563 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
564 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
565 // stripped out by the ARM target.
566
567 // Use software floating point operations?
568 if (FloatABI == "soft") {
569 CmdArgs.push_back("-target-feature");
570 CmdArgs.push_back("+soft-float");
571 }
572
573 // Use software floating point argument passing?
574 if (FloatABI != "hard") {
575 CmdArgs.push_back("-target-feature");
576 CmdArgs.push_back("+soft-float-abi");
577 }
Daniel Dunbara91320b2009-12-21 23:28:17 +0000578
579 // Honor -mfpu=.
580 //
581 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
582 // frontend target.
583 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
584 llvm::StringRef FPU = A->getValue(Args);
585
586 // Set the target features based on the FPU.
587 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
588 // Disable any default FPU support.
589 CmdArgs.push_back("-target-feature");
590 CmdArgs.push_back("-vfp2");
591 CmdArgs.push_back("-target-feature");
592 CmdArgs.push_back("-vfp3");
593 CmdArgs.push_back("-target-feature");
594 CmdArgs.push_back("-neon");
595 } else if (FPU == "vfp") {
596 CmdArgs.push_back("-target-feature");
597 CmdArgs.push_back("+vfp2");
598 } else if (FPU == "vfp3") {
599 CmdArgs.push_back("-target-feature");
600 CmdArgs.push_back("+vfp3");
601 } else if (FPU == "neon") {
602 CmdArgs.push_back("-target-feature");
603 CmdArgs.push_back("+neon");
604 } else
605 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
606 }
Daniel Dunbar7187fac2011-03-17 00:07:34 +0000607
608 // Setting -msoft-float effectively disables NEON because of the GCC
609 // implementation, although the same isn't true of VFP or VFP3.
610 if (FloatABI == "soft") {
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000611 CmdArgs.push_back("-target-feature");
612 CmdArgs.push_back("-neon");
613 }
614
615 // Kernel code has more strict alignment requirements.
616 if (KernelOrKext) {
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000617 CmdArgs.push_back("-backend-option");
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000618 CmdArgs.push_back("-arm-long-calls");
619
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000620 CmdArgs.push_back("-backend-option");
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000621 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbarb5fbb892011-04-18 21:26:42 +0000622
623 // The kext linker doesn't know how to deal with movw/movt.
624#ifndef DISABLE_ARM_DARWIN_USE_MOVT
625 CmdArgs.push_back("-backend-option");
626 CmdArgs.push_back("-arm-darwin-use-movt=0");
627#endif
Daniel Dunbar7187fac2011-03-17 00:07:34 +0000628 }
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000629}
630
Eric Christophered734732010-03-02 02:41:08 +0000631void Clang::AddMIPSTargetArgs(const ArgList &Args,
632 ArgStringList &CmdArgs) const {
633 const Driver &D = getToolChain().getDriver();
634
635 // Select the ABI to use.
636 const char *ABIName = 0;
637 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
638 ABIName = A->getValue(Args);
639 } else {
640 ABIName = "o32";
641 }
642
643 CmdArgs.push_back("-target-abi");
644 CmdArgs.push_back(ABIName);
645
646 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Nick Lewycky574bb5a2011-05-04 03:44:01 +0000647 llvm::StringRef MArch = A->getValue(Args);
Eric Christophered734732010-03-02 02:41:08 +0000648 CmdArgs.push_back("-target-cpu");
649
650 if ((MArch == "r2000") || (MArch == "r3000"))
651 CmdArgs.push_back("mips1");
652 else if (MArch == "r6000")
653 CmdArgs.push_back("mips2");
654 else
Nick Lewycky574bb5a2011-05-04 03:44:01 +0000655 CmdArgs.push_back(Args.MakeArgString(MArch));
Eric Christophered734732010-03-02 02:41:08 +0000656 }
657
658 // Select the float ABI as determined by -msoft-float, -mhard-float, and
659 llvm::StringRef FloatABI;
660 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
661 options::OPT_mhard_float)) {
662 if (A->getOption().matches(options::OPT_msoft_float))
663 FloatABI = "soft";
664 else if (A->getOption().matches(options::OPT_mhard_float))
665 FloatABI = "hard";
666 }
667
668 // If unspecified, choose the default based on the platform.
669 if (FloatABI.empty()) {
Benjamin Kramer71c972a2010-04-08 15:44:22 +0000670 // Assume "soft", but warn the user we are guessing.
671 FloatABI = "soft";
672 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Eric Christophered734732010-03-02 02:41:08 +0000673 }
674
675 if (FloatABI == "soft") {
676 // Floating point operations and argument passing are soft.
677 //
678 // FIXME: This changes CPP defines, we need -target-soft-float.
679 CmdArgs.push_back("-msoft-float");
680 } else {
681 assert(FloatABI == "hard" && "Invalid float abi!");
682 CmdArgs.push_back("-mhard-float");
683 }
684}
685
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +0000686void Clang::AddSparcTargetArgs(const ArgList &Args,
687 ArgStringList &CmdArgs) const {
688 const Driver &D = getToolChain().getDriver();
689
690 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
691 llvm::StringRef MArch = A->getValue(Args);
692 CmdArgs.push_back("-target-cpu");
693 CmdArgs.push_back(MArch.str().c_str());
694 }
695
696 // Select the float ABI as determined by -msoft-float, -mhard-float, and
697 llvm::StringRef FloatABI;
698 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
699 options::OPT_mhard_float)) {
700 if (A->getOption().matches(options::OPT_msoft_float))
701 FloatABI = "soft";
702 else if (A->getOption().matches(options::OPT_mhard_float))
703 FloatABI = "hard";
704 }
705
706 // If unspecified, choose the default based on the platform.
707 if (FloatABI.empty()) {
708 switch (getToolChain().getTriple().getOS()) {
709 default:
710 // Assume "soft", but warn the user we are guessing.
711 FloatABI = "soft";
712 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
713 break;
714 }
715 }
716
717 if (FloatABI == "soft") {
718 // Floating point operations and argument passing are soft.
719 //
720 // FIXME: This changes CPP defines, we need -target-soft-float.
721 CmdArgs.push_back("-msoft-float");
722 CmdArgs.push_back("soft");
723 CmdArgs.push_back("-target-feature");
724 CmdArgs.push_back("+soft-float");
725 } else {
726 assert(FloatABI == "hard" && "Invalid float abi!");
727 CmdArgs.push_back("-mhard-float");
728 }
729}
730
Daniel Dunbar6acda162009-09-09 22:33:08 +0000731void Clang::AddX86TargetArgs(const ArgList &Args,
732 ArgStringList &CmdArgs) const {
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000733 if (!Args.hasFlag(options::OPT_mred_zone,
734 options::OPT_mno_red_zone,
735 true) ||
736 Args.hasArg(options::OPT_mkernel) ||
737 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar66861e02009-11-20 22:21:36 +0000738 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000739
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000740 if (Args.hasFlag(options::OPT_msoft_float,
741 options::OPT_mno_soft_float,
742 false))
Daniel Dunbar66861e02009-11-20 22:21:36 +0000743 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare6ad3f92009-09-10 22:59:57 +0000744
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000745 const char *CPUName = 0;
Daniel Dunbar6acda162009-09-09 22:33:08 +0000746 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000747 if (llvm::StringRef(A->getValue(Args)) == "native") {
748 // FIXME: Reject attempts to use -march=native unless the target matches
749 // the host.
750 //
751 // FIXME: We should also incorporate the detected target features for use
752 // with -native.
753 std::string CPU = llvm::sys::getHostCPUName();
754 if (!CPU.empty())
755 CPUName = Args.MakeArgString(CPU);
756 } else
757 CPUName = A->getValue(Args);
758 }
Daniel Dunbar6acda162009-09-09 22:33:08 +0000759
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000760 // Select the default CPU if none was given (or detection failed).
761 if (!CPUName) {
Daniel Dunbar6acda162009-09-09 22:33:08 +0000762 // FIXME: Need target hooks.
Benjamin Kramerf22d1fd2010-01-30 15:01:47 +0000763 if (getToolChain().getOS().startswith("darwin")) {
Daniel Dunbar6acda162009-09-09 22:33:08 +0000764 if (getToolChain().getArchName() == "x86_64")
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000765 CPUName = "core2";
Daniel Dunbar6acda162009-09-09 22:33:08 +0000766 else if (getToolChain().getArchName() == "i386")
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000767 CPUName = "yonah";
Chris Lattner86ed3a32010-04-11 19:29:39 +0000768 } else if (getToolChain().getOS().startswith("haiku")) {
769 if (getToolChain().getArchName() == "x86_64")
770 CPUName = "x86-64";
771 else if (getToolChain().getArchName() == "i386")
772 CPUName = "i586";
Daniel Dunbar95c04572010-08-01 23:13:54 +0000773 } else if (getToolChain().getOS().startswith("openbsd")) {
774 if (getToolChain().getArchName() == "x86_64")
775 CPUName = "x86-64";
776 else if (getToolChain().getArchName() == "i386")
777 CPUName = "i486";
Roman Divacky451f8ca2011-03-01 18:11:37 +0000778 } else if (getToolChain().getOS().startswith("freebsd")) {
779 if (getToolChain().getArchName() == "x86_64")
780 CPUName = "x86-64";
781 else if (getToolChain().getArchName() == "i386")
782 CPUName = "i486";
Benjamin Kramer8e50a962011-02-02 18:59:27 +0000783 } else if (getToolChain().getOS().startswith("netbsd")) {
784 if (getToolChain().getArchName() == "x86_64")
785 CPUName = "x86-64";
786 else if (getToolChain().getArchName() == "i386")
787 CPUName = "i486";
Daniel Dunbar6acda162009-09-09 22:33:08 +0000788 } else {
789 if (getToolChain().getArchName() == "x86_64")
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000790 CPUName = "x86-64";
Daniel Dunbar6acda162009-09-09 22:33:08 +0000791 else if (getToolChain().getArchName() == "i386")
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000792 CPUName = "pentium4";
Daniel Dunbar6acda162009-09-09 22:33:08 +0000793 }
794 }
795
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000796 if (CPUName) {
Daniel Dunbar38b48af2009-12-18 06:30:12 +0000797 CmdArgs.push_back("-target-cpu");
Daniel Dunbarf86fedd2009-11-14 22:04:54 +0000798 CmdArgs.push_back(CPUName);
799 }
800
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000801 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
802 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000803 llvm::StringRef Name = (*it)->getOption().getName();
804 (*it)->claim();
Daniel Dunbar6acda162009-09-09 22:33:08 +0000805
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000806 // Skip over "-m".
807 assert(Name.startswith("-m") && "Invalid feature name.");
808 Name = Name.substr(2);
Daniel Dunbar6acda162009-09-09 22:33:08 +0000809
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000810 bool IsNegative = Name.startswith("no-");
811 if (IsNegative)
812 Name = Name.substr(3);
Daniel Dunbar6acda162009-09-09 22:33:08 +0000813
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000814 CmdArgs.push_back("-target-feature");
815 CmdArgs.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
Daniel Dunbar6acda162009-09-09 22:33:08 +0000816 }
817}
818
Anders Carlsson525544d2011-02-28 00:44:51 +0000819static bool
820shouldUseExceptionTablesForObjCExceptions(const ArgList &Args,
821 const llvm::Triple &Triple) {
822 // We use the zero-cost exception tables for Objective-C if the non-fragile
823 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
824 // later.
825
826 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi))
827 return true;
828
829 if (Triple.getOS() != llvm::Triple::Darwin)
830 return false;
831
832 return (Triple.getDarwinMajorNumber() >= 9 &&
833 (Triple.getArch() == llvm::Triple::x86_64 ||
834 Triple.getArch() == llvm::Triple::arm));
835}
836
Anders Carlsson15348ae2011-02-28 02:27:16 +0000837/// addExceptionArgs - Adds exception related arguments to the driver command
838/// arguments. There's a master flag, -fexceptions and also language specific
839/// flags to enable/disable C++ and Objective-C exceptions.
840/// This makes it possible to for example disable C++ exceptions but enable
841/// Objective-C exceptions.
842static void addExceptionArgs(const ArgList &Args, types::ID InputType,
843 const llvm::Triple &Triple,
844 bool KernelOrKext, bool IsRewriter,
845 ArgStringList &CmdArgs) {
846 if (KernelOrKext)
847 return;
848
849 // Exceptions are enabled by default.
850 bool ExceptionsEnabled = true;
851
852 // This keeps track of whether exceptions were explicitly turned on or off.
853 bool DidHaveExplicitExceptionFlag = false;
854
Rafael Espindolaf759df02009-10-01 13:33:33 +0000855 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
856 options::OPT_fno_exceptions)) {
857 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlsson15348ae2011-02-28 02:27:16 +0000858 ExceptionsEnabled = true;
859 else
860 ExceptionsEnabled = false;
861
862 DidHaveExplicitExceptionFlag = true;
Rafael Espindolaf759df02009-10-01 13:33:33 +0000863 }
Daniel Dunbar1a2cd4f2010-09-14 23:12:31 +0000864
Anders Carlsson15348ae2011-02-28 02:27:16 +0000865 bool ShouldUseExceptionTables = false;
Fariborz Jahanian85caf032009-10-01 20:30:46 +0000866
Anders Carlsson15348ae2011-02-28 02:27:16 +0000867 // Exception tables and cleanups can be enabled with -fexceptions even if the
868 // language itself doesn't support exceptions.
869 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
870 ShouldUseExceptionTables = true;
Daniel Dunbar1a2cd4f2010-09-14 23:12:31 +0000871
Daniel Dunbard47ea692011-03-17 23:28:31 +0000872 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
873 // is not necessarily sensible, but follows GCC.
874 if (types::isObjC(InputType) &&
875 Args.hasFlag(options::OPT_fobjc_exceptions,
876 options::OPT_fno_objc_exceptions,
877 true)) {
878 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlsson15348ae2011-02-28 02:27:16 +0000879
Daniel Dunbard47ea692011-03-17 23:28:31 +0000880 ShouldUseExceptionTables |=
881 shouldUseExceptionTablesForObjCExceptions(Args, Triple);
Anders Carlsson15348ae2011-02-28 02:27:16 +0000882 }
883
884 if (types::isCXX(InputType)) {
885 bool CXXExceptionsEnabled = ExceptionsEnabled;
886
887 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
888 options::OPT_fno_cxx_exceptions,
889 options::OPT_fexceptions,
890 options::OPT_fno_exceptions)) {
891 if (A->getOption().matches(options::OPT_fcxx_exceptions))
892 CXXExceptionsEnabled = true;
Chandler Carruth43f220f2011-02-28 07:25:18 +0000893 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlsson15348ae2011-02-28 02:27:16 +0000894 CXXExceptionsEnabled = false;
895 }
896
897 if (CXXExceptionsEnabled) {
898 CmdArgs.push_back("-fcxx-exceptions");
899
900 ShouldUseExceptionTables = true;
901 }
902 }
903
904 if (ShouldUseExceptionTables)
905 CmdArgs.push_back("-fexceptions");
Rafael Espindolaf759df02009-10-01 13:33:33 +0000906}
907
Rafael Espindola61b1efe2011-05-02 17:43:32 +0000908static bool ShouldDisableCFI(const ArgList &Args,
909 const ToolChain &TC) {
910
911 // FIXME: Duplicated code with ToolChains.cpp
912 // FIXME: This doesn't belong here, but ideally we will support static soon
913 // anyway.
914 bool HasStatic = (Args.hasArg(options::OPT_mkernel) ||
915 Args.hasArg(options::OPT_static) ||
916 Args.hasArg(options::OPT_fapple_kext));
917 bool IsIADefault = TC.IsIntegratedAssemblerDefault() && !HasStatic;
918 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
919 options::OPT_no_integrated_as,
920 IsIADefault);
921 bool UseCFI = Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
922 options::OPT_fno_dwarf2_cfi_asm,
923 UseIntegratedAs);
924 return !UseCFI;
925}
926
Joerg Sonnenberger359cf922011-05-06 14:35:16 +0000927/// \brief Check whether the given input tree contains any compilation actions.
928static bool ContainsCompileAction(const Action *A) {
929 if (isa<CompileJobAction>(A))
930 return true;
931
932 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
933 if (ContainsCompileAction(*it))
934 return true;
935
936 return false;
937}
938
939/// \brief Check if -relax-all should be passed to the internal assembler.
940/// This is done by default when compiling non-assembler source with -O0.
941static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
942 bool RelaxDefault = true;
943
944 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
945 RelaxDefault = A->getOption().matches(options::OPT_O0);
946
947 if (RelaxDefault) {
948 RelaxDefault = false;
949 for (ActionList::const_iterator it = C.getActions().begin(),
950 ie = C.getActions().end(); it != ie; ++it) {
951 if (ContainsCompileAction(*it)) {
952 RelaxDefault = true;
953 break;
954 }
955 }
956 }
957
958 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
959 RelaxDefault);
960}
961
Daniel Dunbar47ac7d22009-03-18 06:00:36 +0000962void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar871adcf2009-03-18 07:06:02 +0000963 const InputInfo &Output,
Daniel Dunbar62cf6012009-03-18 06:07:59 +0000964 const InputInfoList &Inputs,
Daniel Dunbar1d460332009-03-18 10:01:51 +0000965 const ArgList &Args,
Daniel Dunbar47ac7d22009-03-18 06:00:36 +0000966 const char *LinkingOutput) const {
Daniel Dunbar0a80ba72010-03-20 04:52:14 +0000967 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
968 options::OPT_fapple_kext);
Daniel Dunbaree788e72009-12-21 18:54:17 +0000969 const Driver &D = getToolChain().getDriver();
Daniel Dunbarb488c1d2009-03-18 08:07:30 +0000970 ArgStringList CmdArgs;
971
Daniel Dunbar077ba6a2009-03-31 20:53:55 +0000972 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
973
Daniel Dunbar8ff5b282009-12-11 23:00:49 +0000974 // Invoke ourselves in -cc1 mode.
975 //
976 // FIXME: Implement custom jobs for internal actions.
977 CmdArgs.push_back("-cc1");
978
Daniel Dunbardd4fe002009-10-30 18:12:20 +0000979 // Add the "effective" target triple.
Daniel Dunbaraf07f932009-03-31 17:35:15 +0000980 CmdArgs.push_back("-triple");
Daniel Dunbar00577ad2010-08-23 22:35:37 +0000981 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbardd4fe002009-10-30 18:12:20 +0000982 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbar728a5122009-09-10 06:49:20 +0000983
Daniel Dunbardd4fe002009-10-30 18:12:20 +0000984 // Select the appropriate action.
Daniel Dunbar5314e442010-07-19 19:44:22 +0000985 bool IsRewriter = false;
Daniel Dunbar1d460332009-03-18 10:01:51 +0000986 if (isa<AnalyzeJobAction>(JA)) {
987 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
988 CmdArgs.push_back("-analyze");
989 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +0000990 if (Output.getType() == types::TY_Dependencies)
991 CmdArgs.push_back("-Eonly");
992 else
993 CmdArgs.push_back("-E");
Daniel Dunbar8767cbc2010-02-03 03:07:56 +0000994 } else if (isa<AssembleJobAction>(JA)) {
995 CmdArgs.push_back("-emit-obj");
Daniel Dunbar99298002010-05-27 06:18:05 +0000996
Joerg Sonnenberger359cf922011-05-06 14:35:16 +0000997 if (UseRelaxAll(C, Args))
Daniel Dunbar99298002010-05-27 06:18:05 +0000998 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarca0e0542010-08-24 16:47:49 +0000999
Daniel Dunbarfcec10b2010-10-18 22:36:15 +00001000 // When using an integrated assembler, translate -Wa, and -Xassembler
1001 // options.
1002 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1003 options::OPT_Xassembler),
1004 ie = Args.filtered_end(); it != ie; ++it) {
1005 const Arg *A = *it;
1006 A->claim();
1007
1008 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1009 llvm::StringRef Value = A->getValue(Args, i);
1010
1011 if (Value == "-force_cpusubtype_ALL") {
1012 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbarb14eed02010-10-28 20:36:23 +00001013 } else if (Value == "-L") {
Daniel Dunbar96932322011-03-28 22:49:28 +00001014 CmdArgs.push_back("-msave-temp-labels");
Daniel Dunbarfcec10b2010-10-18 22:36:15 +00001015 } else {
1016 D.Diag(clang::diag::err_drv_unsupported_option_argument)
1017 << A->getOption().getName() << Value;
1018 }
1019 }
1020 }
Daniel Dunbard02bba82010-11-19 16:23:35 +00001021
1022 // Also ignore explicit -force_cpusubtype_ALL option.
1023 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001024 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidise5c35372010-08-11 23:27:58 +00001025 // Use PCH if the user requested it.
Daniel Dunbar0ebd9322009-10-15 20:02:44 +00001026 bool UsePCH = D.CCCUsePCH;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +00001027
1028 if (UsePCH)
Douglas Gregordf91ef32009-04-18 00:34:01 +00001029 CmdArgs.push_back("-emit-pch");
1030 else
1031 CmdArgs.push_back("-emit-pth");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001032 } else {
1033 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001034
Daniel Dunbar1d460332009-03-18 10:01:51 +00001035 if (JA.getType() == types::TY_Nothing) {
1036 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00001037 } else if (JA.getType() == types::TY_LLVM_IR ||
1038 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00001039 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00001040 } else if (JA.getType() == types::TY_LLVM_BC ||
1041 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00001042 CmdArgs.push_back("-emit-llvm-bc");
1043 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbare3b8d072009-09-17 00:47:53 +00001044 CmdArgs.push_back("-S");
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00001045 } else if (JA.getType() == types::TY_AST) {
1046 CmdArgs.push_back("-emit-pch");
Daniel Dunbar64952502010-02-11 03:16:21 +00001047 } else if (JA.getType() == types::TY_RewrittenObjC) {
1048 CmdArgs.push_back("-rewrite-objc");
Daniel Dunbar5314e442010-07-19 19:44:22 +00001049 IsRewriter = true;
Daniel Dunbar64952502010-02-11 03:16:21 +00001050 } else {
1051 assert(JA.getType() == types::TY_PP_Asm &&
1052 "Unexpected output type!");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001053 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001054 }
1055
Daniel Dunbar1d460332009-03-18 10:01:51 +00001056 // The make clang go fast button.
1057 CmdArgs.push_back("-disable-free");
1058
John McCallb689afb2010-02-13 03:50:24 +00001059 // Disable the verification pass in -asserts builds.
1060#ifdef NDEBUG
1061 CmdArgs.push_back("-disable-llvm-verifier");
1062#endif
1063
Daniel Dunbarc9abc042009-04-08 05:11:16 +00001064 // Set the main file name, so that debug info works even with
1065 // -save-temps.
1066 CmdArgs.push_back("-main-file-name");
1067 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
1068
Daniel Dunbar3bbc7532009-04-08 18:03:55 +00001069 // Some flags which affect the language (via preprocessor
1070 // defines). See darwin::CC1::AddCPPArgs.
1071 if (Args.hasArg(options::OPT_static))
1072 CmdArgs.push_back("-static-define");
1073
Daniel Dunbar1d460332009-03-18 10:01:51 +00001074 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenekb8bb3e72009-09-25 05:55:59 +00001075 // Enable region store model by default.
1076 CmdArgs.push_back("-analyzer-store=region");
1077
Ted Kremenekb40d06d2009-12-07 22:26:14 +00001078 // Treat blocks as analysis entry points.
1079 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1080
Ted Kremenek51885072011-03-24 00:28:47 +00001081 CmdArgs.push_back("-analyzer-eagerly-assume");
1082
Daniel Dunbar1d460332009-03-18 10:01:51 +00001083 // Add default argument set.
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00001084 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00001085 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek51885072011-03-24 00:28:47 +00001086 CmdArgs.push_back("-analyzer-checker=deadcode");
1087 CmdArgs.push_back("-analyzer-checker=security");
1088
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00001089 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1090 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek51885072011-03-24 00:28:47 +00001091
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00001092 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek51885072011-03-24 00:28:47 +00001093 CmdArgs.push_back("-analyzer-checker=osx");
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00001094 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001095
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00001096 // Set the output format. The default is plist, for (lame) historical
1097 // reasons.
1098 CmdArgs.push_back("-analyzer-output");
1099 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
1100 CmdArgs.push_back(A->getValue(Args));
1101 else
1102 CmdArgs.push_back("plist");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001103
Ted Kremenek0647a7b2010-03-22 22:32:05 +00001104 // Disable the presentation of standard compiler warnings when
1105 // using --analyze. We only want to show static analyzer diagnostics
1106 // or frontend errors.
1107 CmdArgs.push_back("-w");
1108
Daniel Dunbar1d460332009-03-18 10:01:51 +00001109 // Add -Xanalyzer arguments when running as analyzer.
1110 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump1eb44332009-09-09 15:08:12 +00001111 }
1112
Daniel Dunbare2fd6642009-09-10 01:21:12 +00001113 CheckCodeGenerationOptions(D, Args);
1114
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001115 // Perform argument translation for LLVM backend. This
1116 // takes some care in reconciling with llvm-gcc. The
1117 // issue is that llvm-gcc translates these options based on
1118 // the values in cc1, whereas we are processing based on
1119 // the driver arguments.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001120
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001121 // This comes from the default translation the driver + cc1
1122 // would do to enable flag_pic.
1123 //
1124 // FIXME: Centralize this code.
1125 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
1126 Args.hasArg(options::OPT_fpic) ||
1127 Args.hasArg(options::OPT_fPIE) ||
1128 Args.hasArg(options::OPT_fpie));
1129 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
1130 Args.hasArg(options::OPT_static));
1131 const char *Model = getToolChain().GetForcedPicModel();
1132 if (!Model) {
1133 if (Args.hasArg(options::OPT_mdynamic_no_pic))
1134 Model = "dynamic-no-pic";
1135 else if (PICDisabled)
1136 Model = "static";
1137 else if (PICEnabled)
1138 Model = "pic";
Daniel Dunbar1d460332009-03-18 10:01:51 +00001139 else
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001140 Model = getToolChain().GetDefaultRelocationModel();
Daniel Dunbar1d460332009-03-18 10:01:51 +00001141 }
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001142 if (llvm::StringRef(Model) != "pic") {
1143 CmdArgs.push_back("-mrelocation-model");
1144 CmdArgs.push_back(Model);
1145 }
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001146
1147 // Infer the __PIC__ value.
1148 //
1149 // FIXME: This isn't quite right on Darwin, which always sets
1150 // __PIC__=2.
1151 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
Daniel Dunbar76743522009-11-29 02:39:08 +00001152 CmdArgs.push_back("-pic-level");
1153 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001154 }
Tanya Lattner59876c22009-11-04 01:18:09 +00001155 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1156 options::OPT_fno_merge_all_constants))
Chris Lattnerf44a1a02011-04-08 18:06:54 +00001157 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00001158
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001159 // LLVM Code Generator Options.
1160
Daniel Dunbar17d3fea2011-02-09 17:54:19 +00001161 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1162 CmdArgs.push_back("-mregparm");
1163 CmdArgs.push_back(A->getValue(Args));
1164 }
1165
Roman Divackycfe9af22011-03-01 17:40:53 +00001166 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1167 CmdArgs.push_back("-mrtd");
1168
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001169 // FIXME: Set --enable-unsafe-fp-math.
1170 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
1171 options::OPT_fomit_frame_pointer))
1172 CmdArgs.push_back("-mdisable-fp-elim");
1173 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1174 options::OPT_fno_zero_initialized_in_bss))
1175 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Daniel Dunbar398c6102011-02-04 02:20:39 +00001176 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1177 options::OPT_fno_strict_aliasing,
1178 getToolChain().IsStrictAliasingDefault()))
Dan Gohman4d5625e2010-10-14 22:36:56 +00001179 CmdArgs.push_back("-relaxed-aliasing");
Daniel Dunbar1b718482010-05-14 22:00:22 +00001180
1181 // Decide whether to use verbose asm. Verbose assembly is the default on
1182 // toolchains which have the integrated assembler on by default.
1183 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
1184 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer20249a12010-10-21 03:16:25 +00001185 IsVerboseAsmDefault) ||
Daniel Dunbar1b718482010-05-14 22:00:22 +00001186 Args.hasArg(options::OPT_dA))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001187 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar1b718482010-05-14 22:00:22 +00001188
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001189 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
1190 CmdArgs.push_back("-mdebug-pass");
1191 CmdArgs.push_back("Structure");
1192 }
1193 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
1194 CmdArgs.push_back("-mdebug-pass");
1195 CmdArgs.push_back("Arguments");
1196 }
1197
John McCalld0c2ec42010-02-19 02:45:38 +00001198 // Enable -mconstructor-aliases except on darwin, where we have to
1199 // work around a linker bug; see <rdar://problem/7651567>.
1200 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin)
1201 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00001202
John McCall32096692011-03-18 02:56:14 +00001203 // Darwin's kernel doesn't support guard variables; just die if we
1204 // try to use them.
1205 if (KernelOrKext &&
1206 getToolChain().getTriple().getOS() == llvm::Triple::Darwin)
1207 CmdArgs.push_back("-fforbid-guard-variables");
1208
Douglas Gregor6f755502011-02-01 15:15:22 +00001209 if (Args.hasArg(options::OPT_mms_bitfields)) {
1210 CmdArgs.push_back("-mms-bitfields");
1211 }
John McCalld0c2ec42010-02-19 02:45:38 +00001212
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00001213 // This is a coarse approximation of what llvm-gcc actually does, both
1214 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
1215 // complicated ways.
1216 bool AsynchronousUnwindTables =
1217 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
1218 options::OPT_fno_asynchronous_unwind_tables,
1219 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001220 !KernelOrKext);
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00001221 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
1222 AsynchronousUnwindTables))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001223 CmdArgs.push_back("-munwind-tables");
1224
1225 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
1226 CmdArgs.push_back("-mlimit-float-precision");
1227 CmdArgs.push_back(A->getValue(Args));
1228 }
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001229
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001230 // FIXME: Handle -mtune=.
1231 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001232
Benjamin Kramer8e9ef0d2009-08-05 14:30:52 +00001233 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00001234 CmdArgs.push_back("-mcode-model");
Benjamin Kramer8e9ef0d2009-08-05 14:30:52 +00001235 CmdArgs.push_back(A->getValue(Args));
1236 }
1237
Daniel Dunbar6acda162009-09-09 22:33:08 +00001238 // Add target specific cpu and features flags.
1239 switch(getToolChain().getTriple().getArch()) {
1240 default:
1241 break;
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001242
Daniel Dunbarb163ef72009-09-10 04:57:17 +00001243 case llvm::Triple::arm:
1244 case llvm::Triple::thumb:
Daniel Dunbarfa41d692011-03-17 17:10:06 +00001245 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbarb163ef72009-09-10 04:57:17 +00001246 break;
1247
Eric Christophered734732010-03-02 02:41:08 +00001248 case llvm::Triple::mips:
1249 case llvm::Triple::mipsel:
1250 AddMIPSTargetArgs(Args, CmdArgs);
1251 break;
1252
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001253 case llvm::Triple::sparc:
1254 AddSparcTargetArgs(Args, CmdArgs);
1255 break;
1256
Daniel Dunbar6acda162009-09-09 22:33:08 +00001257 case llvm::Triple::x86:
1258 case llvm::Triple::x86_64:
1259 AddX86TargetArgs(Args, CmdArgs);
1260 break;
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001261 }
1262
Daniel Dunbarc176bc62010-08-11 23:07:47 +00001263 // Pass the linker version in use.
1264 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1265 CmdArgs.push_back("-target-linker-version");
1266 CmdArgs.push_back(A->getValue(Args));
1267 }
1268
Nick Lewyckyb2d11cc2011-02-02 06:43:03 +00001269 // -mno-omit-leaf-frame-pointer is the default on Darwin.
Daniel Dunbar1ad66482010-07-01 01:31:45 +00001270 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
Nick Lewyckyb2d11cc2011-02-02 06:43:03 +00001271 options::OPT_mno_omit_leaf_frame_pointer,
1272 getToolChain().getTriple().getOS() != llvm::Triple::Darwin))
Daniel Dunbar1ad66482010-07-01 01:31:45 +00001273 CmdArgs.push_back("-momit-leaf-frame-pointer");
1274
Dan Gohmanc31176d2010-01-08 02:20:44 +00001275 // -fno-math-errno is default.
1276 if (Args.hasFlag(options::OPT_fmath_errno,
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001277 options::OPT_fno_math_errno,
Dan Gohmanc31176d2010-01-08 02:20:44 +00001278 false))
1279 CmdArgs.push_back("-fmath-errno");
Daniel Dunbarbc85be82009-04-29 18:32:25 +00001280
Daniel Dunbarb30575c2010-05-12 18:19:58 +00001281 // Explicitly error on some things we know we don't support and can't just
1282 // ignore.
1283 types::ID InputType = Inputs[0].getType();
Daniel Dunbare94db472010-09-24 19:39:37 +00001284 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1285 Arg *Unsupported;
1286 if ((Unsupported = Args.getLastArg(options::OPT_MG)) ||
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +00001287 (Unsupported = Args.getLastArg(options::OPT_iframework)))
Daniel Dunbare94db472010-09-24 19:39:37 +00001288 D.Diag(clang::diag::err_drv_clang_unsupported)
Daniel Dunbarb30575c2010-05-12 18:19:58 +00001289 << Unsupported->getOption().getName();
Daniel Dunbare94db472010-09-24 19:39:37 +00001290
1291 if (types::isCXX(InputType) &&
1292 getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1293 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1294 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)))
1295 D.Diag(clang::diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1296 << Unsupported->getOption().getName();
1297 }
Daniel Dunbarb30575c2010-05-12 18:19:58 +00001298 }
1299
Daniel Dunbar1d460332009-03-18 10:01:51 +00001300 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbarf7c16d92010-08-24 22:44:13 +00001301 Args.AddLastArg(CmdArgs, options::OPT_H);
Daniel Dunbar322c29f2011-02-02 21:11:35 +00001302 if (D.CCPrintHeaders) {
1303 CmdArgs.push_back("-header-include-file");
1304 CmdArgs.push_back(D.CCPrintHeadersFilename ?
1305 D.CCPrintHeadersFilename : "-");
1306 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00001307 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump1eb44332009-09-09 15:08:12 +00001308 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001309
Daniel Dunbarc8a22b02011-04-07 18:01:20 +00001310 if (D.CCLogDiagnostics) {
1311 CmdArgs.push_back("-diagnostic-log-file");
1312 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
1313 D.CCLogDiagnosticsFilename : "-");
1314 }
1315
Daniel Dunbar1d460332009-03-18 10:01:51 +00001316 // Special case debug options to only pass -g to clang. This is
1317 // wrong.
Rafael Espindola18f36d92010-03-07 04:46:18 +00001318 Args.ClaimAllArgs(options::OPT_g_Group);
Daniel Dunbar6b3d5a62010-05-12 18:19:55 +00001319 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
1320 if (!A->getOption().matches(options::OPT_g0))
1321 CmdArgs.push_back("-g");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001322
Rafael Espindola9cf933a2010-05-06 21:06:04 +00001323 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1324 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1325
Chris Lattner7255a2d2010-06-22 00:03:40 +00001326 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
1327
Nick Lewyckye8ba8d72011-04-21 23:44:07 +00001328 if (Args.hasArg(options::OPT_ftest_coverage) ||
1329 Args.hasArg(options::OPT_coverage))
1330 CmdArgs.push_back("-femit-coverage-notes");
1331 if (Args.hasArg(options::OPT_fprofile_arcs) ||
1332 Args.hasArg(options::OPT_coverage))
1333 CmdArgs.push_back("-femit-coverage-data");
1334
Nick Lewycky5ea4f442011-05-04 20:46:58 +00001335 if (C.getArgs().hasArg(options::OPT_c) ||
1336 C.getArgs().hasArg(options::OPT_S)) {
1337 if (Output.isFilename()) {
Nick Lewycky3dc05412011-05-05 00:08:20 +00001338 CmdArgs.push_back("-coverage-file");
1339 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
Nick Lewycky5ea4f442011-05-04 20:46:58 +00001340 }
1341 }
1342
Daniel Dunbar1d460332009-03-18 10:01:51 +00001343 Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
Douglas Gregor4c2bcad2010-03-24 20:13:48 +00001344 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
Rafael Espindola8d737cc2009-10-26 13:36:57 +00001345 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001346
Daniel Dunbar5f122322009-12-15 01:02:52 +00001347 // Pass the path to compiler resource files.
Daniel Dunbar5f122322009-12-15 01:02:52 +00001348 CmdArgs.push_back("-resource-dir");
Daniel Dunbar225c4172010-01-20 02:35:16 +00001349 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar2ac9fc22009-04-07 21:42:00 +00001350
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001351 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
1352
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001353 // Add preprocessing options like -I, -D, etc. if we are using the
1354 // preprocessor.
1355 //
1356 // FIXME: Support -fpreprocessed
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001357 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Douglas Gregordf91ef32009-04-18 00:34:01 +00001358 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001359
Daniel Dunbar20f0eac2009-09-17 06:53:36 +00001360 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar337a6272009-03-24 20:17:30 +00001361 // others.
1362 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbarb827a052009-11-19 03:26:40 +00001363 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar337a6272009-03-24 20:17:30 +00001364 CmdArgs.push_back("-O3");
Daniel Dunbar473916c2010-05-27 06:51:08 +00001365 else if (A->getOption().matches(options::OPT_O) &&
1366 A->getValue(Args)[0] == '\0')
Daniel Dunbar20f0eac2009-09-17 06:53:36 +00001367 CmdArgs.push_back("-O2");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001368 else
Daniel Dunbar5697aa02009-03-18 23:39:35 +00001369 A->render(Args, CmdArgs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001370 }
1371
Daniel Dunbar6e8371e2009-10-29 02:24:45 +00001372 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
1373 Args.AddLastArg(CmdArgs, options::OPT_pedantic);
1374 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001375 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbard573d262009-04-07 22:13:21 +00001376
1377 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
1378 // (-ansi is equivalent to -std=c89).
1379 //
1380 // If a std is supplied, only add -trigraphs if it follows the
1381 // option.
1382 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1383 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes528365d2009-10-16 14:28:06 +00001384 if (types::isCXX(InputType))
Daniel Dunbar294691e2009-11-04 06:24:38 +00001385 CmdArgs.push_back("-std=c++98");
Nuno Lopes528365d2009-10-16 14:28:06 +00001386 else
Daniel Dunbar294691e2009-11-04 06:24:38 +00001387 CmdArgs.push_back("-std=c89");
Daniel Dunbard573d262009-04-07 22:13:21 +00001388 else
1389 Std->render(Args, CmdArgs);
1390
Daniel Dunbar0e100312010-06-14 21:23:08 +00001391 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
1392 options::OPT_trigraphs))
1393 if (A != Std)
Daniel Dunbard573d262009-04-07 22:13:21 +00001394 A->render(Args, CmdArgs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00001395 } else {
1396 // Honor -std-default.
Daniel Dunbar4a5290e2010-01-29 21:03:02 +00001397 //
1398 // FIXME: Clang doesn't correctly handle -std= when the input language
1399 // doesn't match. For the time being just ignore this for C++ inputs;
1400 // eventually we want to do all the standard defaulting here instead of
1401 // splitting it between the driver and clang -cc1.
1402 if (!types::isCXX(InputType))
1403 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1404 "-std=", /*Joined=*/true);
Daniel Dunbard573d262009-04-07 22:13:21 +00001405 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00001406 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001407
Chandler Carruth50465d12011-04-23 06:30:43 +00001408 // Map the bizarre '-Wwrite-strings' flag to a more sensible
1409 // '-fconst-strings'; this better indicates its actual behavior.
1410 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
1411 false)) {
1412 // For perfect compatibility with GCC, we do this even in the presence of
1413 // '-w'. This flag names something other than a warning for GCC.
1414 CmdArgs.push_back("-fconst-strings");
1415 }
1416
Chandler Carruth1cfe3c32011-04-23 09:27:53 +00001417 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruthf8c247d2011-04-23 19:48:40 +00001418 // during C++ compilation, which it is by default. GCC keeps this define even
1419 // in the presence of '-w', match this behavior bug-for-bug.
1420 if (types::isCXX(InputType) &&
1421 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
1422 true)) {
1423 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth1cfe3c32011-04-23 09:27:53 +00001424 }
1425
Chandler Carruthc304ba32010-05-22 02:21:53 +00001426 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
1427 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
1428 if (Asm->getOption().matches(options::OPT_fasm))
1429 CmdArgs.push_back("-fgnu-keywords");
1430 else
1431 CmdArgs.push_back("-fno-gnu-keywords");
1432 }
1433
Rafael Espindola61b1efe2011-05-02 17:43:32 +00001434 if (ShouldDisableCFI(Args, getToolChain()))
1435 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolaf24a1512011-04-30 18:35:43 +00001436
Daniel Dunbar1d460332009-03-18 10:01:51 +00001437 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
1438 CmdArgs.push_back("-ftemplate-depth");
1439 CmdArgs.push_back(A->getValue(Args));
1440 }
1441
Argyrios Kyrtzidis1380a142010-11-18 00:20:36 +00001442 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
1443 options::OPT_Wlarge_by_value_copy_def)) {
1444 CmdArgs.push_back("-Wlarge-by-value-copy");
Argyrios Kyrtzidis3532fdd2010-11-17 23:11:54 +00001445 if (A->getNumValues())
1446 CmdArgs.push_back(A->getValue(Args));
1447 else
Argyrios Kyrtzidis1380a142010-11-18 00:20:36 +00001448 CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy.
Argyrios Kyrtzidis3532fdd2010-11-17 23:11:54 +00001449 }
1450
Daniel Dunbare4bdae72009-11-19 04:00:53 +00001451 if (Args.hasArg(options::OPT__relocatable_pch))
Daniel Dunbar66861e02009-11-20 22:21:36 +00001452 CmdArgs.push_back("-relocatable-pch");
Mike Stump1eb44332009-09-09 15:08:12 +00001453
Daniel Dunbar294691e2009-11-04 06:24:38 +00001454 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
1455 CmdArgs.push_back("-fconstant-string-class");
1456 CmdArgs.push_back(A->getValue(Args));
1457 }
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001458
Chris Lattner124fca52010-01-09 21:54:33 +00001459 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
1460 CmdArgs.push_back("-ftabstop");
1461 CmdArgs.push_back(A->getValue(Args));
1462 }
1463
Chris Lattner0f0c9632010-04-07 20:49:23 +00001464 CmdArgs.push_back("-ferror-limit");
1465 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
1466 CmdArgs.push_back(A->getValue(Args));
1467 else
1468 CmdArgs.push_back("19");
Douglas Gregor575cf372010-04-20 07:18:24 +00001469
Chandler Carruthc40f73c2010-05-06 04:55:18 +00001470 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
1471 CmdArgs.push_back("-fmacro-backtrace-limit");
Douglas Gregor6c1cb992010-05-04 17:13:42 +00001472 CmdArgs.push_back(A->getValue(Args));
Chandler Carruthc40f73c2010-05-06 04:55:18 +00001473 }
1474
1475 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
1476 CmdArgs.push_back("-ftemplate-backtrace-limit");
Douglas Gregor575cf372010-04-20 07:18:24 +00001477 CmdArgs.push_back(A->getValue(Args));
Chandler Carruthc40f73c2010-05-06 04:55:18 +00001478 }
1479
Daniel Dunbar55efe142009-11-04 06:24:47 +00001480 // Pass -fmessage-length=.
Daniel Dunbara28690e2009-11-30 08:40:54 +00001481 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar55efe142009-11-04 06:24:47 +00001482 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Daniel Dunbara28690e2009-11-30 08:40:54 +00001483 CmdArgs.push_back(A->getValue(Args));
Daniel Dunbar55efe142009-11-04 06:24:47 +00001484 } else {
1485 // If -fmessage-length=N was not specified, determine whether this is a
1486 // terminal and, if so, implicitly define -fmessage-length appropriately.
1487 unsigned N = llvm::sys::Process::StandardErrColumns();
Daniel Dunbar55efe142009-11-04 06:24:47 +00001488 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N)));
1489 }
1490
Daniel Dunbarba8d8612009-12-03 18:42:11 +00001491 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
1492 CmdArgs.push_back("-fvisibility");
1493 CmdArgs.push_back(A->getValue(Args));
1494 }
1495
Douglas Gregor7cf84d62010-06-15 17:05:35 +00001496 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001497
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001498 // -fhosted is default.
1499 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
1500 options::OPT_fhosted,
1501 false))
1502 CmdArgs.push_back("-ffreestanding");
1503
Daniel Dunbarba8d8612009-12-03 18:42:11 +00001504 // Forward -f (flag) options which we can pass directly.
Mike Stump9c276ae2009-12-12 01:27:46 +00001505 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001506 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001507 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patelc69e1cf2010-09-30 19:05:55 +00001508 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00001509 if (getToolChain().SupportsProfiling())
1510 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar8c6fa842010-03-16 16:57:46 +00001511
1512 // -flax-vector-conversions is default.
1513 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
1514 options::OPT_fno_lax_vector_conversions))
1515 CmdArgs.push_back("-fno-lax-vector-conversions");
1516
Daniel Dunbar43a9b322010-04-10 16:20:23 +00001517 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
1518 // takes precedence.
1519 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
1520 if (!GCArg)
1521 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
1522 if (GCArg) {
1523 if (getToolChain().SupportsObjCGC()) {
1524 GCArg->render(Args, CmdArgs);
1525 } else {
1526 // FIXME: We should move this to a hard error.
1527 D.Diag(clang::diag::warn_drv_objc_gc_unsupported)
1528 << GCArg->getAsString(Args);
1529 }
1530 }
1531
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001532 if (Args.getLastArg(options::OPT_fapple_kext))
1533 CmdArgs.push_back("-fapple-kext");
1534
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001535 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column);
Fariborz Jahanian34e65772009-05-22 20:17:16 +00001536 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner182e0922009-04-21 05:34:31 +00001537 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregor4786c152010-08-19 20:24:43 +00001538 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001539 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
1540 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnall7f18e672010-09-17 18:29:54 +00001541
1542 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
1543 CmdArgs.push_back("-ftrapv-handler");
1544 CmdArgs.push_back(A->getValue(Args));
1545 }
1546
Evan Cheng49af1f32011-04-08 21:37:45 +00001547 // Forward -ftrap_function= options to the backend.
1548 if (Arg *A = Args.getLastArg(options::OPT_ftrap_function_EQ)) {
1549 llvm::StringRef FuncName = A->getValue(Args);
1550 CmdArgs.push_back("-backend-option");
1551 CmdArgs.push_back(Args.MakeArgString("-trap-func=" + FuncName));
1552 }
1553
Chandler Carruth5adb5a82011-03-27 00:04:55 +00001554 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
1555 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
1556 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
1557 options::OPT_fno_wrapv)) {
1558 if (A->getOption().matches(options::OPT_fwrapv))
1559 CmdArgs.push_back("-fwrapv");
1560 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
1561 options::OPT_fno_strict_overflow)) {
1562 if (A->getOption().matches(options::OPT_fno_strict_overflow))
1563 CmdArgs.push_back("-fwrapv");
1564 }
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00001565 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf84d4092010-08-07 23:08:14 +00001566 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001567
Daniel Dunbar5345c392009-09-03 04:54:28 +00001568 Args.AddLastArg(CmdArgs, options::OPT_pthread);
1569
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001570 // -stack-protector=0 is default.
1571 unsigned StackProtectorLevel = 0;
Bill Wendling45483f72009-06-28 07:36:13 +00001572 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
1573 options::OPT_fstack_protector_all,
1574 options::OPT_fstack_protector)) {
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001575 if (A->getOption().matches(options::OPT_fstack_protector))
1576 StackProtectorLevel = 1;
1577 else if (A->getOption().matches(options::OPT_fstack_protector_all))
1578 StackProtectorLevel = 2;
1579 } else
1580 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel();
1581 if (StackProtectorLevel) {
1582 CmdArgs.push_back("-stack-protector");
1583 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel)));
Bill Wendling45483f72009-06-28 07:36:13 +00001584 }
1585
Eric Christopher1a584022011-05-02 21:18:22 +00001586 // Translate -mstackrealign
1587 if (Args.hasArg(options::OPT_mstackrealign)) {
1588 CmdArgs.push_back("-backend-option");
1589 CmdArgs.push_back("-force-align-stack");
1590 }
1591
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001592 // Forward -f options with positive and negative forms; we translate
1593 // these by hand.
1594
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001595 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar2843c192011-02-04 17:24:47 +00001596 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001597 CmdArgs.push_back("-fapple-kext");
1598 if (!Args.hasArg(options::OPT_fbuiltin))
1599 CmdArgs.push_back("-fno-builtin");
1600 }
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001601 // -fbuiltin is default.
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001602 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar53e84842009-11-19 04:55:23 +00001603 CmdArgs.push_back("-fno-builtin");
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001604
Nuno Lopesfc284482009-12-16 16:59:22 +00001605 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1606 options::OPT_fno_assume_sane_operator_new))
1607 CmdArgs.push_back("-fno-assume-sane-operator-new");
1608
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001609 // -fblocks=0 is default.
1610 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnalle6533ff2011-02-28 17:11:43 +00001611 getToolChain().IsBlocksDefault()) ||
1612 (Args.hasArg(options::OPT_fgnu_runtime) &&
1613 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
1614 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001615 CmdArgs.push_back("-fblocks");
David Chisnall5e530af2009-11-17 19:33:30 +00001616 }
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001617
John McCall32579cf2010-04-09 19:12:06 +00001618 // -faccess-control is default.
John McCall7002f4c2010-04-09 19:03:51 +00001619 if (Args.hasFlag(options::OPT_fno_access_control,
1620 options::OPT_faccess_control,
John McCall32579cf2010-04-09 19:12:06 +00001621 false))
John McCall7002f4c2010-04-09 19:03:51 +00001622 CmdArgs.push_back("-fno-access-control");
John McCall3ddd6e02010-03-17 01:32:13 +00001623
Anders Carlssona4c24752010-11-21 00:09:52 +00001624 // -felide-constructors is the default.
1625 if (Args.hasFlag(options::OPT_fno_elide_constructors,
1626 options::OPT_felide_constructors,
1627 false))
1628 CmdArgs.push_back("-fno-elide-constructors");
1629
Anders Carlsson15348ae2011-02-28 02:27:16 +00001630 // Add exception args.
1631 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
1632 KernelOrKext, IsRewriter, CmdArgs);
Mike Stump738f8c22009-07-31 23:15:31 +00001633
Daniel Dunbarb2987d12010-02-10 18:49:11 +00001634 if (getToolChain().UseSjLjExceptions())
1635 CmdArgs.push_back("-fsjlj-exceptions");
1636
Daniel Dunbar0be42c42009-11-17 07:06:20 +00001637 // -frtti is default.
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001638 if (KernelOrKext ||
1639 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
Daniel Dunbar53e84842009-11-19 04:55:23 +00001640 CmdArgs.push_back("-fno-rtti");
Mike Stump738f8c22009-07-31 23:15:31 +00001641
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +00001642 // -fshort-enums=0 is default.
1643 // FIXME: Are there targers where -fshort-enums is on by default ?
1644 if (Args.hasFlag(options::OPT_fshort_enums,
1645 options::OPT_fno_short_enums, false))
1646 CmdArgs.push_back("-fshort-enums");
1647
Daniel Dunbar1f95e652009-11-17 06:37:03 +00001648 // -fsigned-char is default.
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00001649 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbar1f95e652009-11-17 06:37:03 +00001650 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar76743522009-11-29 02:39:08 +00001651 CmdArgs.push_back("-fno-signed-char");
Eli Friedman5a779732009-06-05 07:21:14 +00001652
Anders Carlssona508b7d2010-02-06 23:23:06 +00001653 // -fthreadsafe-static is default.
Michael J. Spencer20249a12010-10-21 03:16:25 +00001654 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssona508b7d2010-02-06 23:23:06 +00001655 options::OPT_fno_threadsafe_statics))
1656 CmdArgs.push_back("-fno-threadsafe-statics");
1657
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001658 // -fuse-cxa-atexit is default.
Anton Korobeynikovd0a57d52010-09-11 11:17:06 +00001659 if (KernelOrKext ||
1660 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
NAKAMURA Takumicd7a30b2010-10-10 01:53:03 +00001661 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00001662 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001663 CmdArgs.push_back("-fno-use-cxa-atexit");
1664
Daniel Dunbar0be42c42009-11-17 07:06:20 +00001665 // -fms-extensions=0 is default.
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00001666 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0be42c42009-11-17 07:06:20 +00001667 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1668 CmdArgs.push_back("-fms-extensions");
1669
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001670 // -fmsc-version=1300 is default.
1671 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1672 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
1673 Args.hasArg(options::OPT_fmsc_version)) {
1674 llvm::StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
1675 if (msc_ver.empty())
1676 CmdArgs.push_back("-fmsc-version=1300");
1677 else
1678 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
1679 }
1680
1681
Dawn Perchik400b6072010-09-02 23:59:25 +00001682 // -fborland-extensions=0 is default.
1683 if (Args.hasFlag(options::OPT_fborland_extensions,
1684 options::OPT_fno_borland_extensions, false))
1685 CmdArgs.push_back("-fborland-extensions");
1686
Francois Pichet8387e2a2011-04-22 22:18:13 +00001687 // -fno-delayed-template-parsing is default.
1688 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
1689 options::OPT_fno_delayed_template_parsing,
1690 false))
1691 CmdArgs.push_back("-fdelayed-template-parsing");
1692
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00001693 // -fgnu-keywords default varies depending on language; only pass if
1694 // specified.
1695 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbar40788d92010-04-24 17:56:39 +00001696 options::OPT_fno_gnu_keywords))
1697 A->render(Args, CmdArgs);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00001698
Daniel Dunbar5314e442010-07-19 19:44:22 +00001699 // -fnext-runtime defaults to on Darwin and when rewriting Objective-C, and is
1700 // -the -cc1 default.
Michael J. Spencer20249a12010-10-21 03:16:25 +00001701 bool NeXTRuntimeIsDefault =
Daniel Dunbar5314e442010-07-19 19:44:22 +00001702 IsRewriter || getToolChain().getTriple().getOS() == llvm::Triple::Darwin;
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00001703 if (!Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
Daniel Dunbar5314e442010-07-19 19:44:22 +00001704 NeXTRuntimeIsDefault))
Daniel Dunbarc5a97ec2009-11-17 07:07:28 +00001705 CmdArgs.push_back("-fgnu-runtime");
1706
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001707 // -fobjc-nonfragile-abi=0 is default.
1708 if (types::isObjC(InputType)) {
Daniel Dunbardea63132010-09-20 18:19:55 +00001709 // Compute the Objective-C ABI "version" to use. Version numbers are
1710 // slightly confusing for historical reasons:
1711 // 1 - Traditional "fragile" ABI
1712 // 2 - Non-fragile ABI, version 1
1713 // 3 - Non-fragile ABI, version 2
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001714 unsigned Version = 1;
Daniel Dunbardea63132010-09-20 18:19:55 +00001715 // If -fobjc-abi-version= is present, use that to set the version.
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001716 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
1717 if (llvm::StringRef(A->getValue(Args)) == "1")
1718 Version = 1;
1719 else if (llvm::StringRef(A->getValue(Args)) == "2")
1720 Version = 2;
Fariborz Jahanian5f81d8a2010-09-15 16:00:51 +00001721 else if (llvm::StringRef(A->getValue(Args)) == "3")
1722 Version = 3;
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001723 else
1724 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbardea63132010-09-20 18:19:55 +00001725 } else {
1726 // Otherwise, determine if we are using the non-fragile ABI.
1727 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
1728 options::OPT_fno_objc_nonfragile_abi,
1729 getToolChain().IsObjCNonFragileABIDefault())) {
1730 // Determine the non-fragile ABI version to use.
Daniel Dunbarde17ba72010-11-11 16:08:59 +00001731#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
1732 unsigned NonFragileABIVersion = 1;
1733#else
Daniel Dunbardea63132010-09-20 18:19:55 +00001734 unsigned NonFragileABIVersion = 2;
Daniel Dunbarde17ba72010-11-11 16:08:59 +00001735#endif
Daniel Dunbardea63132010-09-20 18:19:55 +00001736
1737 if (Arg *A = Args.getLastArg(
1738 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
1739 if (llvm::StringRef(A->getValue(Args)) == "1")
1740 NonFragileABIVersion = 1;
1741 else if (llvm::StringRef(A->getValue(Args)) == "2")
1742 NonFragileABIVersion = 2;
1743 else
1744 D.Diag(clang::diag::err_drv_clang_unsupported)
1745 << A->getAsString(Args);
1746 }
1747
1748 Version = 1 + NonFragileABIVersion;
1749 } else {
1750 Version = 1;
1751 }
Daniel Dunbar5e2a8ac2010-04-28 23:25:24 +00001752 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001753
Fariborz Jahanian5f81d8a2010-09-15 16:00:51 +00001754 if (Version == 2 || Version == 3) {
Fariborz Jahanian112c3302011-01-04 20:05:20 +00001755 CmdArgs.push_back("-fobjc-nonfragile-abi");
Daniel Dunbarf643b9b2010-04-24 17:56:46 +00001756
1757 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
1758 // legacy is the default.
1759 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
1760 options::OPT_fno_objc_legacy_dispatch,
1761 getToolChain().IsObjCLegacyDispatchDefault())) {
1762 if (getToolChain().UseObjCMixedDispatch())
1763 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
1764 else
1765 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
1766 }
Daniel Dunbar984eb862010-02-01 21:07:25 +00001767 }
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00001768
Ted Kremenek29516372011-04-28 19:26:03 +00001769 // FIXME: Don't expose -fobjc-default-synthesize-properties as a top-level
1770 // driver flag yet. This feature is still under active development
1771 // and shouldn't be exposed as a user visible feature (which may change).
1772 // Clang still supports this as a -cc1 option for development and testing.
1773#if 0
Ted Kremenekc32647d2010-12-23 21:35:43 +00001774 // -fobjc-default-synthesize-properties=0 is default.
1775 if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties,
1776 options::OPT_fno_objc_default_synthesize_properties,
1777 getToolChain().IsObjCDefaultSynthPropertiesDefault())) {
1778 CmdArgs.push_back("-fobjc-default-synthesize-properties");
1779 }
Ted Kremenek29516372011-04-28 19:26:03 +00001780#endif
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00001781 }
1782
Daniel Dunbar984eb862010-02-01 21:07:25 +00001783 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1784 options::OPT_fno_assume_sane_operator_new))
1785 CmdArgs.push_back("-fno-assume-sane-operator-new");
1786
Daniel Dunbarf35f14d2010-04-27 15:34:57 +00001787 // -fconstant-cfstrings is default, and may be subject to argument translation
1788 // on Darwin.
1789 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
1790 options::OPT_fno_constant_cfstrings) ||
1791 !Args.hasFlag(options::OPT_mconstant_cfstrings,
1792 options::OPT_mno_constant_cfstrings))
1793 CmdArgs.push_back("-fno-constant-cfstrings");
1794
John Thompsona6fda122009-11-05 20:14:16 +00001795 // -fshort-wchar default varies depending on platform; only
1796 // pass if specified.
Daniel Dunbar1744a352010-04-27 15:35:03 +00001797 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
1798 A->render(Args, CmdArgs);
John Thompsona6fda122009-11-05 20:14:16 +00001799
Daniel Dunbaree848a72009-10-29 02:39:57 +00001800 // -fno-pascal-strings is default, only pass non-default. If the tool chain
1801 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbar82d00682009-04-07 23:51:44 +00001802 //
1803 // FIXME: This is gross; that translation should be pulled from the
1804 // tool chain.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001805 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbar82d00682009-04-07 23:51:44 +00001806 options::OPT_fno_pascal_strings,
1807 false) ||
1808 Args.hasFlag(options::OPT_mpascal_strings,
1809 options::OPT_mno_pascal_strings,
1810 false))
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001811 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00001812
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001813 if (Args.hasArg(options::OPT_mkernel) ||
1814 Args.hasArg(options::OPT_fapple_kext)) {
1815 if (!Args.hasArg(options::OPT_fcommon))
1816 CmdArgs.push_back("-fno-common");
1817 }
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001818 // -fcommon is default, only pass non-default.
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001819 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00001820 CmdArgs.push_back("-fno-common");
1821
Daniel Dunbar70d3c922009-04-15 02:37:43 +00001822 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar06205ca2010-10-15 22:30:42 +00001823 // -funsigned-bitfields.
Mike Stump1eb44332009-09-09 15:08:12 +00001824 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar70d3c922009-04-15 02:37:43 +00001825 options::OPT_funsigned_bitfields))
1826 D.Diag(clang::diag::warn_drv_clang_unsupported)
1827 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
1828
Daniel Dunbar06205ca2010-10-15 22:30:42 +00001829 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
1830 if (!Args.hasFlag(options::OPT_ffor_scope,
1831 options::OPT_fno_for_scope))
1832 D.Diag(clang::diag::err_drv_clang_unsupported)
1833 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
1834
Jeffrey Yasskin0ea22fd2010-06-08 04:56:20 +00001835 // -fcaret-diagnostics is default.
1836 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
1837 options::OPT_fno_caret_diagnostics, true))
1838 CmdArgs.push_back("-fno-caret-diagnostics");
1839
Daniel Dunbar49138fc2009-04-19 21:09:34 +00001840 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump1eb44332009-09-09 15:08:12 +00001841 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar49138fc2009-04-19 21:09:34 +00001842 options::OPT_fno_diagnostics_fixit_info))
1843 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Douglas Gregor7d2b8c12011-04-15 22:04:17 +00001844
1845 // Enable -fdiagnostics-show-name by default.
1846 if (Args.hasFlag(options::OPT_fdiagnostics_show_name,
1847 options::OPT_fno_diagnostics_show_name, false))
1848 CmdArgs.push_back("-fdiagnostics-show-name");
Daniel Dunbar49138fc2009-04-19 21:09:34 +00001849
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00001850 // Enable -fdiagnostics-show-option by default.
Mike Stump1eb44332009-09-09 15:08:12 +00001851 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00001852 options::OPT_fno_diagnostics_show_option))
1853 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar838be482009-11-04 06:24:57 +00001854
Chris Lattner6fbe8392010-05-04 21:55:25 +00001855 if (const Arg *A =
1856 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
1857 CmdArgs.push_back("-fdiagnostics-show-category");
1858 CmdArgs.push_back(A->getValue(Args));
1859 }
Daniel Dunbarca0e0542010-08-24 16:47:49 +00001860
Chandler Carruthabaca7a2011-03-27 01:50:55 +00001861 if (Arg *A = Args.getLastArg(
1862 options::OPT_fdiagnostics_show_note_include_stack,
1863 options::OPT_fno_diagnostics_show_note_include_stack)) {
1864 if (A->getOption().matches(
1865 options::OPT_fdiagnostics_show_note_include_stack))
1866 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
1867 else
1868 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
1869 }
1870
Daniel Dunbar838be482009-11-04 06:24:57 +00001871 // Color diagnostics are the default, unless the terminal doesn't support
1872 // them.
1873 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidisf765d762010-09-23 12:56:06 +00001874 options::OPT_fno_color_diagnostics,
1875 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar838be482009-11-04 06:24:57 +00001876 CmdArgs.push_back("-fcolor-diagnostics");
1877
Daniel Dunbar75eb1d62009-06-08 21:13:54 +00001878 if (!Args.hasFlag(options::OPT_fshow_source_location,
1879 options::OPT_fno_show_source_location))
1880 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00001881
Douglas Gregora0068fc2010-07-09 17:35:33 +00001882 if (!Args.hasFlag(options::OPT_fspell_checking,
1883 options::OPT_fno_spell_checking))
1884 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarca0e0542010-08-24 16:47:49 +00001885
Daniel Dunbar25b26eb2010-10-18 22:49:46 +00001886
Daniel Dunbar16894392010-11-02 19:42:04 +00001887 // Silently ignore -fasm-blocks for now.
1888 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
1889 false);
Daniel Dunbar25b26eb2010-10-18 22:49:46 +00001890
Jeffrey Yasskin5edbdcc2010-06-11 05:57:47 +00001891 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
1892 A->render(Args, CmdArgs);
1893
Daniel Dunbar7695fba2009-04-19 21:20:32 +00001894 // -fdollars-in-identifiers default varies depending on platform and
1895 // language; only pass if specified.
Mike Stump1eb44332009-09-09 15:08:12 +00001896 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbar7695fba2009-04-19 21:20:32 +00001897 options::OPT_fno_dollars_in_identifiers)) {
1898 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar8663b182009-12-16 20:10:18 +00001899 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbar7695fba2009-04-19 21:20:32 +00001900 else
Daniel Dunbar8663b182009-12-16 20:10:18 +00001901 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbar7695fba2009-04-19 21:20:32 +00001902 }
1903
Daniel Dunbare027a4b2009-05-22 19:02:20 +00001904 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
1905 // practical purposes.
Mike Stump1eb44332009-09-09 15:08:12 +00001906 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbare027a4b2009-05-22 19:02:20 +00001907 options::OPT_fno_unit_at_a_time)) {
1908 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Edward O'Callaghanc3769102009-10-13 16:41:34 +00001909 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbare027a4b2009-05-22 19:02:20 +00001910 }
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00001911
Daniel Dunbar2ba91572009-09-10 03:37:02 +00001912 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00001913 //
Daniel Dunbar8ff5b282009-12-11 23:00:49 +00001914 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00001915#if 0
Daniel Dunbar2ba91572009-09-10 03:37:02 +00001916 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1917 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
1918 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
1919 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
1920 CmdArgs.push_back("-fno-builtin-strcat");
1921 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
1922 CmdArgs.push_back("-fno-builtin-strcpy");
1923 }
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00001924#endif
Daniel Dunbar2ba91572009-09-10 03:37:02 +00001925
Daniel Dunbard98750f2011-03-18 21:23:40 +00001926 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump1eb44332009-09-09 15:08:12 +00001927 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbard98750f2011-03-18 21:23:40 +00001928 options::OPT_traditional_cpp)) {
1929 if (isa<PreprocessJobAction>(JA))
1930 CmdArgs.push_back("-traditional-cpp");
1931 else
1932 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
1933 }
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00001934
Daniel Dunbar1d460332009-03-18 10:01:51 +00001935 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnerd82df3a2009-04-12 01:56:53 +00001936 Args.AddLastArg(CmdArgs, options::OPT_dD);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001937
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00001938 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
1939 // parser.
Daniel Dunbar1d460332009-03-18 10:01:51 +00001940 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00001941 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
1942 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001943 (*it)->claim();
Daniel Dunbarfb36d212010-04-17 06:10:00 +00001944
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00001945 // We translate this by hand to the -cc1 argument, since nightly test uses
1946 // it and developers have been trained to spell it with -mllvm.
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001947 if (llvm::StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00001948 CmdArgs.push_back("-disable-llvm-optzns");
1949 else
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001950 (*it)->render(Args, CmdArgs);
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00001951 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00001952
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +00001953 if (Output.getType() == types::TY_Dependencies) {
1954 // Handled with other dependency code.
Daniel Dunbar115a7922009-03-19 07:29:38 +00001955 } else if (Output.isFilename()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001956 CmdArgs.push_back("-o");
Daniel Dunbar115a7922009-03-19 07:29:38 +00001957 CmdArgs.push_back(Output.getFilename());
1958 } else {
1959 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001960 }
1961
Daniel Dunbar1d460332009-03-18 10:01:51 +00001962 for (InputInfoList::const_iterator
1963 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1964 const InputInfo &II = *it;
1965 CmdArgs.push_back("-x");
1966 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00001967 if (II.isFilename())
Daniel Dunbar115a7922009-03-19 07:29:38 +00001968 CmdArgs.push_back(II.getFilename());
Daniel Dunbar1d460332009-03-18 10:01:51 +00001969 else
Daniel Dunbar115a7922009-03-19 07:29:38 +00001970 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001971 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001972
Chris Lattnere6113de2009-11-03 19:50:27 +00001973 Args.AddAllArgs(CmdArgs, options::OPT_undef);
1974
Daniel Dunbara001c1c2010-07-18 21:16:15 +00001975 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00001976
1977 // Optionally embed the -cc1 level arguments into the debug info, for build
1978 // analysis.
1979 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar6e900472010-06-04 18:47:06 +00001980 ArgStringList OriginalArgs;
1981 for (ArgList::const_iterator it = Args.begin(),
1982 ie = Args.end(); it != ie; ++it)
1983 (*it)->render(Args, OriginalArgs);
Daniel Dunbarca0e0542010-08-24 16:47:49 +00001984
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00001985 llvm::SmallString<256> Flags;
1986 Flags += Exec;
Daniel Dunbar6e900472010-06-04 18:47:06 +00001987 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00001988 Flags += " ";
Daniel Dunbar6e900472010-06-04 18:47:06 +00001989 Flags += OriginalArgs[i];
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00001990 }
1991 CmdArgs.push_back("-dwarf-debug-flags");
1992 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
1993 }
1994
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00001995 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbara880db02009-03-23 19:03:36 +00001996
Roman Divackybe4c8702011-02-10 16:52:03 +00001997 if (Arg *A = Args.getLastArg(options::OPT_pg))
1998 if (Args.hasArg(options::OPT_fomit_frame_pointer))
1999 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2000 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002001
Daniel Dunbar68fb4692009-04-03 20:51:31 +00002002 // Claim some arguments which clang supports automatically.
2003
Daniel Dunbarf4046862010-04-15 06:18:42 +00002004 // -fpch-preprocess is used with gcc to add a special marker in the output to
2005 // include the PCH file. Clang's PTH solution is completely transparent, so we
2006 // do not need to deal with it at all.
Daniel Dunbar68fb4692009-04-03 20:51:31 +00002007 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002008
Daniel Dunbara880db02009-03-23 19:03:36 +00002009 // Claim some arguments which clang doesn't support, but we don't
2010 // care to warn the user about.
Daniel Dunbarcdd96862009-11-25 11:53:23 +00002011 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
2012 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola035ff0c2011-02-28 23:29:45 +00002013
Rafael Espindola9c094fb2011-03-01 05:25:27 +00002014 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
Rafael Espindola035ff0c2011-02-28 23:29:45 +00002015 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00002016 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002017}
2018
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002019void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002020 const InputInfo &Output,
2021 const InputInfoList &Inputs,
2022 const ArgList &Args,
2023 const char *LinkingOutput) const {
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002024 ArgStringList CmdArgs;
2025
2026 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2027 const InputInfo &Input = Inputs[0];
2028
Rafael Espindoladbe80d92010-11-17 22:13:25 +00002029 // Don't warn about "clang -w -c foo.s"
2030 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00002031 // and "clang -emit-llvm -c foo.s"
2032 Args.ClaimAllArgs(options::OPT_emit_llvm);
2033 // and "clang -use-gold-plugin -c foo.s"
2034 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindoladbe80d92010-11-17 22:13:25 +00002035
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002036 // Invoke ourselves in -cc1as mode.
2037 //
2038 // FIXME: Implement custom jobs for internal actions.
2039 CmdArgs.push_back("-cc1as");
2040
2041 // Add the "effective" target triple.
2042 CmdArgs.push_back("-triple");
Daniel Dunbar00577ad2010-08-23 22:35:37 +00002043 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002044 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2045
2046 // Set the output mode, we currently only expect to be used as a real
2047 // assembler.
2048 CmdArgs.push_back("-filetype");
2049 CmdArgs.push_back("obj");
2050
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00002051 if (UseRelaxAll(C, Args))
Daniel Dunbar469d40e2010-05-28 16:43:21 +00002052 CmdArgs.push_back("-relax-all");
Daniel Dunbar99298002010-05-27 06:18:05 +00002053
Daniel Dunbar7f6f8c82011-03-17 17:37:29 +00002054 // Ignore explicit -force_cpusubtype_ALL option.
2055 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002056
2057 // FIXME: Add -g support, once we have it.
2058
2059 // FIXME: Add -static support, once we have it.
2060
2061 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2062 options::OPT_Xassembler);
Daniel Dunbar3df23252011-04-29 17:53:18 +00002063 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002064
2065 assert(Output.isFilename() && "Unexpected lipo output.");
2066 CmdArgs.push_back("-o");
2067 CmdArgs.push_back(Output.getFilename());
2068
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002069 assert(Input.isFilename() && "Invalid input.");
2070 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002071
Daniel Dunbara001c1c2010-07-18 21:16:15 +00002072 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002073 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00002074}
2075
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002076void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002077 const InputInfo &Output,
2078 const InputInfoList &Inputs,
Daniel Dunbar1d460332009-03-18 10:01:51 +00002079 const ArgList &Args,
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002080 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002081 const Driver &D = getToolChain().getDriver();
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002082 ArgStringList CmdArgs;
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002083
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002084 for (ArgList::const_iterator
Daniel Dunbar1d460332009-03-18 10:01:51 +00002085 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002086 Arg *A = *it;
Daniel Dunbar75877192009-03-19 07:55:12 +00002087 if (A->getOption().hasForwardToGCC()) {
Daniel Dunbar2dffe2d2010-08-03 16:14:14 +00002088 // Don't forward any -g arguments to assembly steps.
2089 if (isa<AssembleJobAction>(JA) &&
2090 A->getOption().matches(options::OPT_g_Group))
2091 continue;
2092
Daniel Dunbar75877192009-03-19 07:55:12 +00002093 // It is unfortunate that we have to claim here, as this means
2094 // we will basically never report anything interesting for
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002095 // platforms using a generic gcc, even if we are just using gcc
2096 // to get to the assembler.
Daniel Dunbar75877192009-03-19 07:55:12 +00002097 A->claim();
Daniel Dunbar1d460332009-03-18 10:01:51 +00002098 A->render(Args, CmdArgs);
Daniel Dunbar75877192009-03-19 07:55:12 +00002099 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002100 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002101
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002102 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002103
2104 // If using a driver driver, force the arch.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002105 const std::string &Arch = getToolChain().getArchName();
Daniel Dunbar1bda4342009-12-23 00:46:38 +00002106 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002107 CmdArgs.push_back("-arch");
Daniel Dunbarbf54a062009-04-01 20:33:11 +00002108
2109 // FIXME: Remove these special cases.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002110 if (Arch == "powerpc")
2111 CmdArgs.push_back("ppc");
2112 else if (Arch == "powerpc64")
2113 CmdArgs.push_back("ppc64");
2114 else
Daniel Dunbar88137642009-09-09 22:32:48 +00002115 CmdArgs.push_back(Args.MakeArgString(Arch));
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002116 }
2117
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002118 // Try to force gcc to match the tool chain we want, if we recognize
2119 // the arch.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002120 //
2121 // FIXME: The triple class should directly provide the information we want
2122 // here.
2123 if (Arch == "i386" || Arch == "powerpc")
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002124 CmdArgs.push_back("-m32");
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00002125 else if (Arch == "x86_64" || Arch == "powerpc64")
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00002126 CmdArgs.push_back("-m64");
2127
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002128 if (Output.isFilename()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002129 CmdArgs.push_back("-o");
Daniel Dunbar115a7922009-03-19 07:29:38 +00002130 CmdArgs.push_back(Output.getFilename());
2131 } else {
2132 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002133 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar115a7922009-03-19 07:29:38 +00002134 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002135
2136
2137 // Only pass -x if gcc will understand it; otherwise hope gcc
2138 // understands the suffix correctly. The main use case this would go
2139 // wrong in is for linker inputs if they happened to have an odd
2140 // suffix; really the only way to get this to happen is a command
2141 // like '-x foobar a.c' which will treat a.c like a linker input.
2142 //
2143 // FIXME: For the linker case specifically, can we safely convert
2144 // inputs into '-Wl,' options?
2145 for (InputInfoList::const_iterator
2146 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2147 const InputInfo &II = *it;
Daniel Dunbara8304f62009-05-02 20:14:53 +00002148
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002149 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002150 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
2151 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Daniel Dunbara8304f62009-05-02 20:14:53 +00002152 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002153 << getToolChain().getTripleString();
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002154 else if (II.getType() == types::TY_AST)
2155 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002156 << getToolChain().getTripleString();
Daniel Dunbara8304f62009-05-02 20:14:53 +00002157
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002158 if (types::canTypeBeUserSpecified(II.getType())) {
2159 CmdArgs.push_back("-x");
2160 CmdArgs.push_back(types::getTypeName(II.getType()));
2161 }
2162
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002163 if (II.isFilename())
Daniel Dunbar115a7922009-03-19 07:29:38 +00002164 CmdArgs.push_back(II.getFilename());
Daniel Dunbar48f99942010-09-25 18:10:05 +00002165 else {
2166 const Arg &A = II.getInputArg();
2167
2168 // Reverse translate some rewritten options.
2169 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
2170 CmdArgs.push_back("-lstdc++");
2171 continue;
2172 }
2173
Daniel Dunbar115a7922009-03-19 07:29:38 +00002174 // Don't render as input, we need gcc to do the translations.
Daniel Dunbar48f99942010-09-25 18:10:05 +00002175 A.render(Args, CmdArgs);
2176 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002177 }
2178
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +00002179 const std::string customGCCName = D.getCCCGenericGCCName();
2180 const char *GCCName;
2181 if (!customGCCName.empty())
2182 GCCName = customGCCName.c_str();
2183 else if (D.CCCIsCXX) {
2184#ifdef IS_CYGWIN15
2185 // FIXME: Detect the version of Cygwin at runtime?
2186 GCCName = "g++-4";
2187#else
2188 GCCName = "g++";
2189#endif
2190 } else
2191 GCCName = "gcc";
2192
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002193 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002194 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002195 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002196}
2197
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002198void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
2199 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002200 CmdArgs.push_back("-E");
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002201}
2202
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002203void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
2204 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002205 // The type is good enough.
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002206}
2207
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002208void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
2209 ArgStringList &CmdArgs) const {
Daniel Dunbar64952502010-02-11 03:16:21 +00002210 const Driver &D = getToolChain().getDriver();
2211
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002212 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002213 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
2214 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002215 CmdArgs.push_back("-c");
Daniel Dunbar64952502010-02-11 03:16:21 +00002216 else {
2217 if (JA.getType() != types::TY_PP_Asm)
2218 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
2219 << getTypeName(JA.getType());
Michael J. Spencer20249a12010-10-21 03:16:25 +00002220
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002221 CmdArgs.push_back("-S");
Daniel Dunbar64952502010-02-11 03:16:21 +00002222 }
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002223}
2224
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002225void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
2226 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002227 CmdArgs.push_back("-c");
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00002228}
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002229
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00002230void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
2231 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00002232 // The types are (hopefully) good enough.
2233}
2234
Daniel Dunbar40f12652009-03-29 17:08:39 +00002235const char *darwin::CC1::getCC1Name(types::ID Type) const {
2236 switch (Type) {
2237 default:
2238 assert(0 && "Unexpected type for Darwin CC1 tool.");
2239 case types::TY_Asm:
2240 case types::TY_C: case types::TY_CHeader:
2241 case types::TY_PP_C: case types::TY_PP_CHeader:
2242 return "cc1";
2243 case types::TY_ObjC: case types::TY_ObjCHeader:
2244 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader:
2245 return "cc1obj";
2246 case types::TY_CXX: case types::TY_CXXHeader:
2247 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
2248 return "cc1plus";
2249 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
2250 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader:
2251 return "cc1objplus";
2252 }
2253}
2254
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002255const char *darwin::CC1::getBaseInputName(const ArgList &Args,
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002256 const InputInfoList &Inputs) {
Michael J. Spencer472ccff2010-12-18 00:19:12 +00002257 return Args.MakeArgString(
2258 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002259}
2260
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002261const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002262 const InputInfoList &Inputs) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002263 const char *Str = getBaseInputName(Args, Inputs);
2264
Chris Lattner657ca662011-01-16 08:14:11 +00002265 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar88137642009-09-09 22:32:48 +00002266 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002267
2268 return Str;
2269}
2270
2271const char *
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002272darwin::CC1::getDependencyFileName(const ArgList &Args,
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002273 const InputInfoList &Inputs) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002274 // FIXME: Think about this more.
2275 std::string Res;
2276
2277 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2278 std::string Str(OutputOpt->getValue(Args));
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002279
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002280 Res = Str.substr(0, Str.rfind('.'));
2281 } else
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002282 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002283
Daniel Dunbar88137642009-09-09 22:32:48 +00002284 return Args.MakeArgString(Res + ".d");
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002285}
2286
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002287void darwin::CC1::AddCC1Args(const ArgList &Args,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002288 ArgStringList &CmdArgs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002289 const Driver &D = getToolChain().getDriver();
Daniel Dunbare2fd6642009-09-10 01:21:12 +00002290
2291 CheckCodeGenerationOptions(D, Args);
2292
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002293 // Derived from cc1 spec.
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002294 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
2295 !Args.hasArg(options::OPT_mdynamic_no_pic))
2296 CmdArgs.push_back("-fPIC");
2297
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002298 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2299 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2300 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2301 CmdArgs.push_back("-fno-builtin-strcat");
2302 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2303 CmdArgs.push_back("-fno-builtin-strcpy");
2304 }
2305
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002306 if (Args.hasArg(options::OPT_g_Flag) &&
2307 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
2308 CmdArgs.push_back("-feliminate-unused-debug-symbols");
2309}
2310
2311void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2312 const InputInfoList &Inputs,
2313 const ArgStringList &OutputArgs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002314 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002315
2316 // Derived from cc1_options spec.
2317 if (Args.hasArg(options::OPT_fast) ||
2318 Args.hasArg(options::OPT_fastf) ||
2319 Args.hasArg(options::OPT_fastcp))
2320 CmdArgs.push_back("-O3");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002321
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002322 if (Arg *A = Args.getLastArg(options::OPT_pg))
2323 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2324 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2325 << A->getAsString(Args) << "-fomit-frame-pointer";
2326
2327 AddCC1Args(Args, CmdArgs);
2328
2329 if (!Args.hasArg(options::OPT_Q))
2330 CmdArgs.push_back("-quiet");
2331
2332 CmdArgs.push_back("-dumpbase");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002333 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002334
2335 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2336
2337 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2338 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
2339
2340 // FIXME: The goal is to use the user provided -o if that is our
2341 // final output, otherwise to drive from the original input
2342 // name. Find a clean way to go about this.
2343 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
2344 Args.hasArg(options::OPT_o)) {
2345 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
2346 CmdArgs.push_back("-auxbase-strip");
2347 CmdArgs.push_back(OutputOpt->getValue(Args));
2348 } else {
2349 CmdArgs.push_back("-auxbase");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002350 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002351 }
2352
2353 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
2354
2355 Args.AddAllArgs(CmdArgs, options::OPT_O);
2356 // FIXME: -Wall is getting some special treatment. Investigate.
2357 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2358 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002359 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002360 options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00002361 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2362 // Honor -std-default.
2363 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2364 "-std=", /*Joined=*/true);
2365 }
2366
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002367 if (Args.hasArg(options::OPT_v))
2368 CmdArgs.push_back("-version");
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00002369 if (Args.hasArg(options::OPT_pg) &&
2370 getToolChain().SupportsProfiling())
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002371 CmdArgs.push_back("-p");
2372 Args.AddLastArg(CmdArgs, options::OPT_p);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002373
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002374 // The driver treats -fsyntax-only specially.
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002375 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2376 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2377 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
2378 // used to inhibit the default -fno-builtin-str{cat,cpy}.
2379 //
2380 // FIXME: Should we grow a better way to deal with "removing" args?
Daniel Dunbarcdd96862009-11-25 11:53:23 +00002381 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
2382 options::OPT_fsyntax_only),
2383 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00002384 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
2385 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
2386 (*it)->claim();
2387 (*it)->render(Args, CmdArgs);
Daniel Dunbar2ba91572009-09-10 03:37:02 +00002388 }
2389 }
2390 } else
2391 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002392
Daniel Dunbar089f8722011-04-07 20:41:03 +00002393 // Claim Clang only -f options, they aren't worth warning about.
2394 Args.ClaimAllArgs(options::OPT_f_clang_Group);
2395
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002396 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2397 if (Args.hasArg(options::OPT_Qn))
2398 CmdArgs.push_back("-fno-ident");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002399
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002400 // FIXME: This isn't correct.
2401 //Args.AddLastArg(CmdArgs, options::OPT__help)
2402 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
2403
2404 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2405
2406 // FIXME: Still don't get what is happening here. Investigate.
2407 Args.AddAllArgs(CmdArgs, options::OPT__param);
2408
2409 if (Args.hasArg(options::OPT_fmudflap) ||
2410 Args.hasArg(options::OPT_fmudflapth)) {
2411 CmdArgs.push_back("-fno-builtin");
2412 CmdArgs.push_back("-fno-merge-constants");
2413 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002414
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002415 if (Args.hasArg(options::OPT_coverage)) {
2416 CmdArgs.push_back("-fprofile-arcs");
2417 CmdArgs.push_back("-ftest-coverage");
2418 }
2419
2420 if (types::isCXX(Inputs[0].getType()))
2421 CmdArgs.push_back("-D__private_extern__=extern");
2422}
2423
2424void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2425 const InputInfoList &Inputs,
2426 const ArgStringList &OutputArgs) const {
2427 // Derived from cpp_options
2428 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002429
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002430 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2431
2432 AddCC1Args(Args, CmdArgs);
2433
2434 // NOTE: The code below has some commonality with cpp_options, but
2435 // in classic gcc style ends up sending things in different
2436 // orders. This may be a good merge candidate once we drop pedantic
2437 // compatibility.
2438
2439 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002440 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002441 options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00002442 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2443 // Honor -std-default.
2444 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2445 "-std=", /*Joined=*/true);
2446 }
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002447 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2448 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002449
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002450 // The driver treats -fsyntax-only specially.
2451 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2452
Daniel Dunbar089f8722011-04-07 20:41:03 +00002453 // Claim Clang only -f options, they aren't worth warning about.
2454 Args.ClaimAllArgs(options::OPT_f_clang_Group);
2455
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002456 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
2457 !Args.hasArg(options::OPT_fno_working_directory))
2458 CmdArgs.push_back("-fworking-directory");
2459
2460 Args.AddAllArgs(CmdArgs, options::OPT_O);
2461 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2462 if (Args.hasArg(options::OPT_save_temps))
2463 CmdArgs.push_back("-fpch-preprocess");
2464}
2465
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002466void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002467 ArgStringList &CmdArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00002468 const InputInfoList &Inputs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002469 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002470
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +00002471 CheckPreprocessingOptions(D, Args);
2472
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002473 // Derived from cpp_unique_options.
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +00002474 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
2475 Args.AddLastArg(CmdArgs, options::OPT_C);
2476 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002477 if (!Args.hasArg(options::OPT_Q))
2478 CmdArgs.push_back("-quiet");
2479 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
Douglas Gregor4c2bcad2010-03-24 20:13:48 +00002480 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002481 Args.AddLastArg(CmdArgs, options::OPT_v);
2482 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
2483 Args.AddLastArg(CmdArgs, options::OPT_P);
2484
2485 // FIXME: Handle %I properly.
2486 if (getToolChain().getArchName() == "x86_64") {
2487 CmdArgs.push_back("-imultilib");
2488 CmdArgs.push_back("x86_64");
2489 }
2490
2491 if (Args.hasArg(options::OPT_MD)) {
2492 CmdArgs.push_back("-MD");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002493 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002494 }
2495
2496 if (Args.hasArg(options::OPT_MMD)) {
2497 CmdArgs.push_back("-MMD");
Daniel Dunbara5a7bd02009-03-30 00:34:04 +00002498 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002499 }
2500
2501 Args.AddLastArg(CmdArgs, options::OPT_M);
2502 Args.AddLastArg(CmdArgs, options::OPT_MM);
2503 Args.AddAllArgs(CmdArgs, options::OPT_MF);
2504 Args.AddLastArg(CmdArgs, options::OPT_MG);
2505 Args.AddLastArg(CmdArgs, options::OPT_MP);
2506 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
2507 Args.AddAllArgs(CmdArgs, options::OPT_MT);
2508 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
2509 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
2510 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2511 CmdArgs.push_back("-MQ");
2512 CmdArgs.push_back(OutputOpt->getValue(Args));
2513 }
2514 }
2515
2516 Args.AddLastArg(CmdArgs, options::OPT_remap);
2517 if (Args.hasArg(options::OPT_g3))
2518 CmdArgs.push_back("-dD");
2519 Args.AddLastArg(CmdArgs, options::OPT_H);
2520
2521 AddCPPArgs(Args, CmdArgs);
2522
2523 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
2524 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
2525
2526 for (InputInfoList::const_iterator
2527 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2528 const InputInfo &II = *it;
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002529
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002530 CmdArgs.push_back(II.getFilename());
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002531 }
2532
2533 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
2534 options::OPT_Xpreprocessor);
2535
2536 if (Args.hasArg(options::OPT_fmudflap)) {
2537 CmdArgs.push_back("-D_MUDFLAP");
2538 CmdArgs.push_back("-include");
2539 CmdArgs.push_back("mf-runtime.h");
2540 }
2541
2542 if (Args.hasArg(options::OPT_fmudflapth)) {
2543 CmdArgs.push_back("-D_MUDFLAP");
2544 CmdArgs.push_back("-D_MUDFLAPTH");
2545 CmdArgs.push_back("-include");
2546 CmdArgs.push_back("mf-runtime.h");
2547 }
2548}
2549
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002550void darwin::CC1::AddCPPArgs(const ArgList &Args,
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002551 ArgStringList &CmdArgs) const {
2552 // Derived from cpp spec.
2553
2554 if (Args.hasArg(options::OPT_static)) {
2555 // The gcc spec is broken here, it refers to dynamic but
2556 // that has been translated. Start by being bug compatible.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002557
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002558 // if (!Args.hasArg(arglist.parser.dynamicOption))
2559 CmdArgs.push_back("-D__STATIC__");
2560 } else
2561 CmdArgs.push_back("-D__DYNAMIC__");
2562
2563 if (Args.hasArg(options::OPT_pthread))
2564 CmdArgs.push_back("-D_REENTRANT");
2565}
2566
Daniel Dunbar40f12652009-03-29 17:08:39 +00002567void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002568 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002569 const InputInfoList &Inputs,
2570 const ArgList &Args,
Daniel Dunbar40f12652009-03-29 17:08:39 +00002571 const char *LinkingOutput) const {
2572 ArgStringList CmdArgs;
2573
2574 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2575
2576 CmdArgs.push_back("-E");
2577
2578 if (Args.hasArg(options::OPT_traditional) ||
Daniel Dunbar40f12652009-03-29 17:08:39 +00002579 Args.hasArg(options::OPT_traditional_cpp))
2580 CmdArgs.push_back("-traditional-cpp");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002581
Daniel Dunbar40f12652009-03-29 17:08:39 +00002582 ArgStringList OutputArgs;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002583 assert(Output.isFilename() && "Unexpected CC1 output.");
2584 OutputArgs.push_back("-o");
2585 OutputArgs.push_back(Output.getFilename());
Daniel Dunbar40f12652009-03-29 17:08:39 +00002586
Joerg Sonnenberger9ade4ae2011-03-06 23:31:01 +00002587 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
Daniel Dunbar9120f172009-03-29 22:27:40 +00002588 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2589 } else {
2590 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2591 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2592 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002593
Daniel Dunbar8a2073a2009-04-03 01:27:06 +00002594 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2595
Daniel Dunbar40f12652009-03-29 17:08:39 +00002596 const char *CC1Name = getCC1Name(Inputs[0].getType());
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002597 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002598 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002599 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar40f12652009-03-29 17:08:39 +00002600}
2601
2602void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002603 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002604 const InputInfoList &Inputs,
2605 const ArgList &Args,
Daniel Dunbar40f12652009-03-29 17:08:39 +00002606 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002607 const Driver &D = getToolChain().getDriver();
Daniel Dunbar40f12652009-03-29 17:08:39 +00002608 ArgStringList CmdArgs;
2609
2610 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2611
2612 types::ID InputType = Inputs[0].getType();
2613 const Arg *A;
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00002614 if ((A = Args.getLastArg(options::OPT_traditional)))
Daniel Dunbar40f12652009-03-29 17:08:39 +00002615 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2616 << A->getAsString(Args) << "-E";
2617
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002618 if (JA.getType() == types::TY_LLVM_IR ||
2619 JA.getType() == types::TY_LTO_IR)
Daniel Dunbar40f12652009-03-29 17:08:39 +00002620 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00002621 else if (JA.getType() == types::TY_LLVM_BC ||
2622 JA.getType() == types::TY_LTO_BC)
Daniel Dunbar40f12652009-03-29 17:08:39 +00002623 CmdArgs.push_back("-emit-llvm-bc");
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002624 else if (Output.getType() == types::TY_AST)
2625 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002626 << getToolChain().getTripleString();
Daniel Dunbarae24a882010-02-11 17:33:45 +00002627 else if (JA.getType() != types::TY_PP_Asm &&
2628 JA.getType() != types::TY_PCH)
Daniel Dunbar64952502010-02-11 03:16:21 +00002629 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
2630 << getTypeName(JA.getType());
Daniel Dunbar40f12652009-03-29 17:08:39 +00002631
2632 ArgStringList OutputArgs;
2633 if (Output.getType() != types::TY_PCH) {
2634 OutputArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002635 if (Output.isNothing())
Daniel Dunbar40f12652009-03-29 17:08:39 +00002636 OutputArgs.push_back("/dev/null");
2637 else
2638 OutputArgs.push_back(Output.getFilename());
2639 }
2640
2641 // There is no need for this level of compatibility, but it makes
2642 // diffing easier.
2643 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
2644 Args.hasArg(options::OPT_S));
2645
2646 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00002647 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
Daniel Dunbar40f12652009-03-29 17:08:39 +00002648 if (OutputArgsEarly) {
2649 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2650 } else {
2651 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2652 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2653 }
2654 } else {
2655 CmdArgs.push_back("-fpreprocessed");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002656
Daniel Dunbar40f12652009-03-29 17:08:39 +00002657 for (InputInfoList::const_iterator
2658 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2659 const InputInfo &II = *it;
2660
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002661 // Reject AST inputs.
2662 if (II.getType() == types::TY_AST) {
2663 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00002664 << getToolChain().getTripleString();
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00002665 return;
2666 }
2667
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002668 CmdArgs.push_back(II.getFilename());
Daniel Dunbar40f12652009-03-29 17:08:39 +00002669 }
2670
2671 if (OutputArgsEarly) {
2672 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2673 } else {
2674 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2675 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2676 }
2677 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002678
Daniel Dunbar40f12652009-03-29 17:08:39 +00002679 if (Output.getType() == types::TY_PCH) {
2680 assert(Output.isFilename() && "Invalid PCH output.");
2681
2682 CmdArgs.push_back("-o");
2683 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
2684 // to be a good reason.
2685 CmdArgs.push_back("/dev/null");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002686
Daniel Dunbare6c9ae12009-11-21 02:31:29 +00002687 CmdArgs.push_back("--output-pch=");
Daniel Dunbar40f12652009-03-29 17:08:39 +00002688 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002689 }
Daniel Dunbar40f12652009-03-29 17:08:39 +00002690
2691 const char *CC1Name = getCC1Name(Inputs[0].getType());
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002692 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002693 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002694 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar40f12652009-03-29 17:08:39 +00002695}
2696
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002697void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002698 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002699 const InputInfoList &Inputs,
2700 const ArgList &Args,
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002701 const char *LinkingOutput) const {
2702 ArgStringList CmdArgs;
2703
2704 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2705 const InputInfo &Input = Inputs[0];
2706
Daniel Dunbar34bac1f2011-04-12 23:59:20 +00002707 // Determine the original source input.
2708 const Action *SourceAction = &JA;
2709 while (SourceAction->getKind() != Action::InputClass) {
2710 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
2711 SourceAction = SourceAction->getInputs()[0];
2712 }
2713
2714 // Forward -g, assuming we are dealing with an actual assembly file.
2715 if (SourceAction->getType() == types::TY_Asm ||
2716 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar8e4fea62009-04-01 00:27:44 +00002717 if (Args.hasArg(options::OPT_gstabs))
2718 CmdArgs.push_back("--gstabs");
2719 else if (Args.hasArg(options::OPT_g_Group))
2720 CmdArgs.push_back("--gdwarf2");
2721 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002722
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002723 // Derived from asm spec.
Daniel Dunbarcc6f8032009-09-09 18:36:27 +00002724 AddDarwinArch(Args, CmdArgs);
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002725
Daniel Dunbarf5438e32010-07-22 01:47:22 +00002726 // Use -force_cpusubtype_ALL on x86 by default.
2727 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
2728 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbarcc6f8032009-09-09 18:36:27 +00002729 Args.hasArg(options::OPT_force__cpusubtype__ALL))
2730 CmdArgs.push_back("-force_cpusubtype_ALL");
2731
Daniel Dunbar0e2679d2009-08-24 22:26:16 +00002732 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
2733 (Args.hasArg(options::OPT_mkernel) ||
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002734 Args.hasArg(options::OPT_static) ||
Daniel Dunbar0e2679d2009-08-24 22:26:16 +00002735 Args.hasArg(options::OPT_fapple_kext)))
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002736 CmdArgs.push_back("-static");
2737
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002738 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2739 options::OPT_Xassembler);
2740
2741 assert(Output.isFilename() && "Unexpected lipo output.");
2742 CmdArgs.push_back("-o");
2743 CmdArgs.push_back(Output.getFilename());
2744
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00002745 assert(Input.isFilename() && "Invalid input.");
2746 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002747
2748 // asm_final spec is empty.
2749
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002750 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00002751 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002752 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00002753}
Daniel Dunbarff7488d2009-03-20 00:52:38 +00002754
Daniel Dunbarfbefe6b2009-09-09 18:36:20 +00002755void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
2756 ArgStringList &CmdArgs) const {
Daniel Dunbareeff4062010-01-22 02:04:58 +00002757 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
2758
Daniel Dunbar02633b52009-03-26 16:23:12 +00002759 // Derived from darwin_arch spec.
2760 CmdArgs.push_back("-arch");
Daniel Dunbareeff4062010-01-22 02:04:58 +00002761 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar78dbd582009-09-04 18:35:31 +00002762
Daniel Dunbareeff4062010-01-22 02:04:58 +00002763 // FIXME: Is this needed anymore?
2764 if (ArchName == "arm")
Daniel Dunbar78dbd582009-09-04 18:35:31 +00002765 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbar02633b52009-03-26 16:23:12 +00002766}
2767
Daniel Dunbar748de8e2010-09-09 21:51:05 +00002768void darwin::Link::AddLinkArgs(Compilation &C,
2769 const ArgList &Args,
Daniel Dunbar02633b52009-03-26 16:23:12 +00002770 ArgStringList &CmdArgs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00002771 const Driver &D = getToolChain().getDriver();
Daniel Dunbarce911f52011-04-28 21:23:41 +00002772 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbar02633b52009-03-26 16:23:12 +00002773
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00002774 unsigned Version[3] = { 0, 0, 0 };
2775 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2776 bool HadExtra;
2777 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
2778 Version[1], Version[2], HadExtra) ||
2779 HadExtra)
2780 D.Diag(clang::diag::err_drv_invalid_version_number)
2781 << A->getAsString(Args);
2782 }
2783
2784 // Newer linkers support -demangle, pass it if supported and not disabled by
2785 // the user.
Daniel Dunbara30d6cd2010-11-19 17:51:40 +00002786 //
2787 // FIXME: We temporarily avoid passing -demangle to any iOS linker, because
2788 // unfortunately we can't be guaranteed that the linker version used there
2789 // will match the linker version detected at configure time. We need the
2790 // universal driver.
2791 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) &&
Daniel Dunbarce911f52011-04-28 21:23:41 +00002792 !DarwinTC.isTargetIPhoneOS()) {
Daniel Dunbarbcf1da82010-09-07 17:07:49 +00002793 // Don't pass -demangle to ld_classic.
2794 //
2795 // FIXME: This is a temporary workaround, ld should be handling this.
2796 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
2797 Args.hasArg(options::OPT_static));
Daniel Dunbar9ced7042010-09-07 17:50:41 +00002798 if (getToolChain().getArch() == llvm::Triple::x86) {
2799 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
2800 options::OPT_Wl_COMMA),
2801 ie = Args.filtered_end(); it != ie; ++it) {
2802 const Arg *A = *it;
2803 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
2804 if (llvm::StringRef(A->getValue(Args, i)) == "-kext")
2805 UsesLdClassic = true;
2806 }
2807 }
Daniel Dunbarbcf1da82010-09-07 17:07:49 +00002808 if (!UsesLdClassic)
2809 CmdArgs.push_back("-demangle");
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00002810 }
2811
Daniel Dunbar02633b52009-03-26 16:23:12 +00002812 // Derived from the "link" spec.
2813 Args.AddAllArgs(CmdArgs, options::OPT_static);
2814 if (!Args.hasArg(options::OPT_static))
2815 CmdArgs.push_back("-dynamic");
2816 if (Args.hasArg(options::OPT_fgnu_runtime)) {
2817 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
2818 // here. How do we wish to handle such things?
2819 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002820
Daniel Dunbar02633b52009-03-26 16:23:12 +00002821 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara6d38492010-01-22 02:04:52 +00002822 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara6d38492010-01-22 02:04:52 +00002823 // FIXME: Why do this only on this path?
Daniel Dunbar8917dd42010-01-22 03:37:33 +00002824 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbar02633b52009-03-26 16:23:12 +00002825
2826 Args.AddLastArg(CmdArgs, options::OPT_bundle);
2827 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
2828 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
2829
2830 Arg *A;
2831 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
2832 (A = Args.getLastArg(options::OPT_current__version)) ||
2833 (A = Args.getLastArg(options::OPT_install__name)))
2834 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2835 << A->getAsString(Args) << "-dynamiclib";
2836
2837 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
2838 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
2839 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
2840 } else {
2841 CmdArgs.push_back("-dylib");
2842
2843 Arg *A;
2844 if ((A = Args.getLastArg(options::OPT_bundle)) ||
2845 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
2846 (A = Args.getLastArg(options::OPT_client__name)) ||
2847 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
2848 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
2849 (A = Args.getLastArg(options::OPT_private__bundle)))
2850 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2851 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002852
Daniel Dunbar02633b52009-03-26 16:23:12 +00002853 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
2854 "-dylib_compatibility_version");
2855 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
2856 "-dylib_current_version");
2857
Daniel Dunbara6d38492010-01-22 02:04:52 +00002858 AddDarwinArch(Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00002859
2860 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
2861 "-dylib_install_name");
2862 }
2863
2864 Args.AddLastArg(CmdArgs, options::OPT_all__load);
2865 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
2866 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarce911f52011-04-28 21:23:41 +00002867 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00002868 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbar02633b52009-03-26 16:23:12 +00002869 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
2870 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
2871 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
2872 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
2873 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
2874 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
2875 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
2876 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
2877 Args.AddAllArgs(CmdArgs, options::OPT_init);
2878
Daniel Dunbarce911f52011-04-28 21:23:41 +00002879 // Add the deployment target.
2880 unsigned TargetVersion[3];
2881 DarwinTC.getTargetVersion(TargetVersion);
Daniel Dunbarb7f5ef72011-04-30 04:22:58 +00002882
2883 // If we had an explicit -mios-simulator-version-min argument, honor that,
2884 // otherwise use the traditional deployment targets. We can't just check the
2885 // is-sim attribute because existing code follows this path, and the linker
2886 // may not handle the argument.
2887 //
2888 // FIXME: We may be able to remove this, once we can verify no one depends on
2889 // it.
2890 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
2891 CmdArgs.push_back("-ios_simulator_version_min");
2892 else if (DarwinTC.isTargetIPhoneOS())
2893 CmdArgs.push_back("-iphoneos_version_min");
2894 else
2895 CmdArgs.push_back("-macosx_version_min");
Daniel Dunbarce911f52011-04-28 21:23:41 +00002896 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(TargetVersion[0]) + "." +
2897 llvm::Twine(TargetVersion[1]) + "." +
2898 llvm::Twine(TargetVersion[2])));
2899
Daniel Dunbar02633b52009-03-26 16:23:12 +00002900 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
2901 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
2902 Args.AddLastArg(CmdArgs, options::OPT_single__module);
2903 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
2904 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002905
Daniel Dunbar47e879d2010-07-13 23:31:40 +00002906 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
2907 options::OPT_fno_pie,
2908 options::OPT_fno_PIE)) {
2909 if (A->getOption().matches(options::OPT_fpie) ||
2910 A->getOption().matches(options::OPT_fPIE))
2911 CmdArgs.push_back("-pie");
2912 else
2913 CmdArgs.push_back("-no_pie");
2914 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00002915
2916 Args.AddLastArg(CmdArgs, options::OPT_prebind);
2917 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
2918 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
2919 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
2920 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
2921 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
2922 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
2923 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
2924 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
2925 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
2926 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
2927 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
2928 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
2929 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
2930 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
2931 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00002932
Daniel Dunbarcc957192011-05-02 21:03:47 +00002933 // Give --sysroot= preference, over the Apple specific behavior to also use
2934 // --isysroot as the syslibroot.
2935 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
2936 CmdArgs.push_back("-syslibroot");
2937 CmdArgs.push_back(A->getValue(Args));
2938 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2939 CmdArgs.push_back("-syslibroot");
2940 CmdArgs.push_back(A->getValue(Args));
2941 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
2942 CmdArgs.push_back("-syslibroot");
2943 CmdArgs.push_back("/Developer/SDKs/Extra");
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00002944 }
2945
Daniel Dunbar02633b52009-03-26 16:23:12 +00002946 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
2947 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
2948 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
2949 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
2950 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00002951 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbar02633b52009-03-26 16:23:12 +00002952 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
2953 Args.AddAllArgs(CmdArgs, options::OPT_y);
2954 Args.AddLastArg(CmdArgs, options::OPT_w);
2955 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
2956 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
2957 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
2958 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
2959 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
2960 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
2961 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
2962 Args.AddLastArg(CmdArgs, options::OPT_whyload);
2963 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
2964 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
2965 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
2966 Args.AddLastArg(CmdArgs, options::OPT_Mach);
2967}
2968
2969void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00002970 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002971 const InputInfoList &Inputs,
2972 const ArgList &Args,
Daniel Dunbar02633b52009-03-26 16:23:12 +00002973 const char *LinkingOutput) const {
2974 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbare0be8b12009-09-08 16:39:16 +00002975
Daniel Dunbar02633b52009-03-26 16:23:12 +00002976 // The logic here is derived from gcc's behavior; most of which
2977 // comes from specs (starting with link_command). Consult gcc for
2978 // more information.
Daniel Dunbar02633b52009-03-26 16:23:12 +00002979 ArgStringList CmdArgs;
2980
2981 // I'm not sure why this particular decomposition exists in gcc, but
2982 // we follow suite for ease of comparison.
Daniel Dunbar748de8e2010-09-09 21:51:05 +00002983 AddLinkArgs(C, Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00002984
Daniel Dunbar02633b52009-03-26 16:23:12 +00002985 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
2986 Args.AddAllArgs(CmdArgs, options::OPT_s);
2987 Args.AddAllArgs(CmdArgs, options::OPT_t);
2988 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
2989 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
2990 Args.AddAllArgs(CmdArgs, options::OPT_A);
2991 Args.AddLastArg(CmdArgs, options::OPT_e);
2992 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
2993 Args.AddAllArgs(CmdArgs, options::OPT_r);
2994
Daniel Dunbar270073c2010-10-18 22:08:36 +00002995 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
2996 // members of static archive libraries which implement Objective-C classes or
2997 // categories.
2998 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
2999 CmdArgs.push_back("-ObjC");
Michael J. Spencer20249a12010-10-21 03:16:25 +00003000
Daniel Dunbar02633b52009-03-26 16:23:12 +00003001 CmdArgs.push_back("-o");
3002 CmdArgs.push_back(Output.getFilename());
3003
Daniel Dunbar02633b52009-03-26 16:23:12 +00003004 if (!Args.hasArg(options::OPT_A) &&
3005 !Args.hasArg(options::OPT_nostdlib) &&
3006 !Args.hasArg(options::OPT_nostartfiles)) {
3007 // Derived from startfile spec.
3008 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003009 // Derived from darwin_dylib1 spec.
Daniel Dunbar1051fc02011-04-01 21:02:42 +00003010 if (getDarwinToolChain().isTargetIOSSimulator()) {
3011 // The simulator doesn't have a versioned crt1 file.
3012 CmdArgs.push_back("-ldylib1.o");
3013 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003014 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3015 CmdArgs.push_back("-ldylib1.o");
3016 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003017 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003018 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003019 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003020 CmdArgs.push_back("-ldylib1.10.5.o");
3021 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003022 } else {
3023 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbar8a8d8af2009-04-01 03:17:40 +00003024 if (!Args.hasArg(options::OPT_static)) {
3025 // Derived from darwin_bundle1 spec.
Daniel Dunbar1051fc02011-04-01 21:02:42 +00003026 if (getDarwinToolChain().isTargetIOSSimulator()) {
3027 // The simulator doesn't have a versioned crt1 file.
3028 CmdArgs.push_back("-lbundle1.o");
3029 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003030 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3031 CmdArgs.push_back("-lbundle1.o");
3032 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003033 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003034 CmdArgs.push_back("-lbundle1.o");
3035 }
Daniel Dunbar8a8d8af2009-04-01 03:17:40 +00003036 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003037 } else {
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00003038 if (Args.hasArg(options::OPT_pg) &&
3039 getToolChain().SupportsProfiling()) {
Daniel Dunbar02633b52009-03-26 16:23:12 +00003040 if (Args.hasArg(options::OPT_static) ||
3041 Args.hasArg(options::OPT_object) ||
3042 Args.hasArg(options::OPT_preload)) {
3043 CmdArgs.push_back("-lgcrt0.o");
3044 } else {
3045 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003046
Daniel Dunbar02633b52009-03-26 16:23:12 +00003047 // darwin_crt2 spec is empty.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003048 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003049 } else {
3050 if (Args.hasArg(options::OPT_static) ||
3051 Args.hasArg(options::OPT_object) ||
3052 Args.hasArg(options::OPT_preload)) {
3053 CmdArgs.push_back("-lcrt0.o");
3054 } else {
3055 // Derived from darwin_crt1 spec.
Daniel Dunbar40355802011-03-31 17:12:33 +00003056 if (getDarwinToolChain().isTargetIOSSimulator()) {
3057 // The simulator doesn't have a versioned crt1 file.
3058 CmdArgs.push_back("-lcrt1.o");
3059 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00003060 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3061 CmdArgs.push_back("-lcrt1.o");
3062 else
3063 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003064 } else {
3065 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
3066 CmdArgs.push_back("-lcrt1.o");
3067 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3068 CmdArgs.push_back("-lcrt1.10.5.o");
3069 else
3070 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003071
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003072 // darwin_crt2 spec is empty.
3073 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00003074 }
3075 }
3076 }
3077 }
3078
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00003079 if (!getDarwinToolChain().isTargetIPhoneOS() &&
3080 Args.hasArg(options::OPT_shared_libgcc) &&
3081 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar88137642009-09-09 22:32:48 +00003082 const char *Str =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003083 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar88137642009-09-09 22:32:48 +00003084 CmdArgs.push_back(Str);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003085 }
3086 }
3087
3088 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003089
Daniel Dunbar02633b52009-03-26 16:23:12 +00003090 if (Args.hasArg(options::OPT_fopenmp))
3091 // This is more complicated in gcc...
3092 CmdArgs.push_back("-lgomp");
3093
Daniel Dunbar6b200b22009-09-18 08:14:36 +00003094 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003095
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003096 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003097
3098 if (LinkingOutput) {
3099 CmdArgs.push_back("-arch_multiple");
3100 CmdArgs.push_back("-final_output");
3101 CmdArgs.push_back(LinkingOutput);
3102 }
3103
3104 if (Args.hasArg(options::OPT_fprofile_arcs) ||
3105 Args.hasArg(options::OPT_fprofile_generate) ||
3106 Args.hasArg(options::OPT_fcreate_profile) ||
3107 Args.hasArg(options::OPT_coverage))
3108 CmdArgs.push_back("-lgcov");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003109
Daniel Dunbar02633b52009-03-26 16:23:12 +00003110 if (Args.hasArg(options::OPT_fnested_functions))
3111 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003112
Daniel Dunbar02633b52009-03-26 16:23:12 +00003113 if (!Args.hasArg(options::OPT_nostdlib) &&
3114 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003115 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar132e35d2010-09-17 01:20:05 +00003116 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbaredfa02b2009-04-08 06:06:21 +00003117
Daniel Dunbar02633b52009-03-26 16:23:12 +00003118 // link_ssp spec is empty.
3119
Daniel Dunbar6cd41542009-09-18 08:15:03 +00003120 // Let the tool chain choose which runtime library to link.
3121 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00003122 }
3123
3124 if (!Args.hasArg(options::OPT_A) &&
3125 !Args.hasArg(options::OPT_nostdlib) &&
3126 !Args.hasArg(options::OPT_nostartfiles)) {
3127 // endfile_spec is empty.
3128 }
3129
3130 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3131 Args.AddAllArgs(CmdArgs, options::OPT_F);
3132
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003133 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003134 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003135 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar02633b52009-03-26 16:23:12 +00003136}
3137
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003138void darwin::Lipo::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 Dunbarff7488d2009-03-20 00:52:38 +00003142 const char *LinkingOutput) const {
3143 ArgStringList CmdArgs;
3144
3145 CmdArgs.push_back("-create");
3146 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbara428df82009-03-24 00:24:37 +00003147
3148 CmdArgs.push_back("-output");
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003149 CmdArgs.push_back(Output.getFilename());
Daniel Dunbara428df82009-03-24 00:24:37 +00003150
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003151 for (InputInfoList::const_iterator
3152 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3153 const InputInfo &II = *it;
3154 assert(II.isFilename() && "Unexpected lipo input.");
3155 CmdArgs.push_back(II.getFilename());
3156 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003157 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003158 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003159 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarff7488d2009-03-20 00:52:38 +00003160}
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003161
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003162void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003163 const InputInfo &Output,
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003164 const InputInfoList &Inputs,
3165 const ArgList &Args,
3166 const char *LinkingOutput) const {
3167 ArgStringList CmdArgs;
3168
Daniel Dunbar03e92302011-05-09 17:23:16 +00003169 CmdArgs.push_back("-o");
3170 CmdArgs.push_back(Output.getFilename());
3171
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003172 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
3173 const InputInfo &Input = Inputs[0];
3174 assert(Input.isFilename() && "Unexpected dsymutil input.");
3175 CmdArgs.push_back(Input.getFilename());
3176
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003177 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003178 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003179 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00003180}
3181
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003182void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003183 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00003184 const InputInfoList &Inputs,
3185 const ArgList &Args,
3186 const char *LinkingOutput) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003187 ArgStringList CmdArgs;
3188
3189 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3190 options::OPT_Xassembler);
3191
3192 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003193 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003194
3195 for (InputInfoList::const_iterator
3196 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3197 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003198 CmdArgs.push_back(II.getFilename());
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003199 }
3200
3201 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003202 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003203 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003204}
3205
3206void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003207 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00003208 const InputInfoList &Inputs,
3209 const ArgList &Args,
3210 const char *LinkingOutput) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003211 ArgStringList CmdArgs;
3212
3213 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar294691e2009-11-04 06:24:38 +00003214 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003215 CmdArgs.push_back("-e");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00003216 CmdArgs.push_back("_start");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003217 }
3218
3219 if (Args.hasArg(options::OPT_static)) {
3220 CmdArgs.push_back("-Bstatic");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00003221 CmdArgs.push_back("-dn");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003222 } else {
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00003223// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003224 CmdArgs.push_back("-Bdynamic");
3225 if (Args.hasArg(options::OPT_shared)) {
3226 CmdArgs.push_back("-shared");
3227 } else {
Edward O'Callaghan3cecc192009-10-16 19:44:18 +00003228 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003229 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
3230 }
3231 }
3232
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003233 if (Output.isFilename()) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003234 CmdArgs.push_back("-o");
3235 CmdArgs.push_back(Output.getFilename());
3236 } else {
3237 assert(Output.isNothing() && "Invalid output.");
3238 }
3239
3240 if (!Args.hasArg(options::OPT_nostdlib) &&
3241 !Args.hasArg(options::OPT_nostartfiles)) {
3242 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00003243 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003244 getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003245 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003246 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003247 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003248 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003249 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00003250 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003251 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003252 }
Chris Lattner38e317d2010-07-07 16:01:42 +00003253 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003254 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003255 }
3256
Daniel Dunbar294691e2009-11-04 06:24:38 +00003257 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
3258 + getToolChain().getTripleString()
Daniel Dunbarf7fb31f2009-10-29 02:24:37 +00003259 + "/4.2.4"));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003260
3261 Args.AddAllArgs(CmdArgs, options::OPT_L);
3262 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3263 Args.AddAllArgs(CmdArgs, options::OPT_e);
3264
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003265 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003266
3267 if (!Args.hasArg(options::OPT_nostdlib) &&
3268 !Args.hasArg(options::OPT_nodefaultlibs)) {
3269 // FIXME: For some reason GCC passes -lgcc before adding
3270 // the default system libraries. Just mimic this for now.
3271 CmdArgs.push_back("-lgcc");
3272
3273 if (Args.hasArg(options::OPT_pthread))
3274 CmdArgs.push_back("-pthread");
3275 if (!Args.hasArg(options::OPT_shared))
3276 CmdArgs.push_back("-lc");
3277 CmdArgs.push_back("-lgcc");
3278 }
3279
3280 if (!Args.hasArg(options::OPT_nostdlib) &&
3281 !Args.hasArg(options::OPT_nostartfiles)) {
3282 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00003283 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003284 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003285 }
3286
3287 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003288 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003289 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00003290}
3291
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003292void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003293 const InputInfo &Output,
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003294 const InputInfoList &Inputs,
3295 const ArgList &Args,
Mike Stump1eb44332009-09-09 15:08:12 +00003296 const char *LinkingOutput) const {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003297 ArgStringList CmdArgs;
3298
3299 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3300 options::OPT_Xassembler);
3301
3302 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003303 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003304
3305 for (InputInfoList::const_iterator
3306 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3307 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003308 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003309 }
3310
3311 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003312 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003313 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003314}
3315
3316void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003317 const InputInfo &Output,
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003318 const InputInfoList &Inputs,
3319 const ArgList &Args,
3320 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003321 const Driver &D = getToolChain().getDriver();
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003322 ArgStringList CmdArgs;
3323
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003324 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar294691e2009-11-04 06:24:38 +00003325 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003326 CmdArgs.push_back("-e");
3327 CmdArgs.push_back("__start");
3328 }
3329
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003330 if (Args.hasArg(options::OPT_static)) {
3331 CmdArgs.push_back("-Bstatic");
3332 } else {
Rafael Espindola65ba55d2010-11-11 02:17:51 +00003333 if (Args.hasArg(options::OPT_rdynamic))
3334 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003335 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003336 CmdArgs.push_back("-Bdynamic");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003337 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003338 CmdArgs.push_back("-shared");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003339 } else {
3340 CmdArgs.push_back("-dynamic-linker");
3341 CmdArgs.push_back("/usr/libexec/ld.so");
3342 }
3343 }
3344
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003345 if (Output.isFilename()) {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003346 CmdArgs.push_back("-o");
3347 CmdArgs.push_back(Output.getFilename());
3348 } else {
3349 assert(Output.isNothing() && "Invalid output.");
3350 }
3351
3352 if (!Args.hasArg(options::OPT_nostdlib) &&
3353 !Args.hasArg(options::OPT_nostartfiles)) {
3354 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00003355 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003356 getToolChain().GetFilePath("crt0.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003357 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003358 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003359 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00003360 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003361 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003362 }
3363 }
3364
Edward O'Callaghane7e18202009-10-28 15:13:08 +00003365 std::string Triple = getToolChain().getTripleString();
3366 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar294691e2009-11-04 06:24:38 +00003367 Triple.replace(0, 6, "amd64");
Daniel Dunbarf7fb31f2009-10-29 02:24:37 +00003368 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbar95c04572010-08-01 23:13:54 +00003369 "/4.2.1"));
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003370
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003371 Args.AddAllArgs(CmdArgs, options::OPT_L);
3372 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3373 Args.AddAllArgs(CmdArgs, options::OPT_e);
3374
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003375 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003376
3377 if (!Args.hasArg(options::OPT_nostdlib) &&
3378 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar95c04572010-08-01 23:13:54 +00003379 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00003380 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbar95c04572010-08-01 23:13:54 +00003381 CmdArgs.push_back("-lm");
3382 }
3383
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003384 // FIXME: For some reason GCC passes -lgcc before adding
3385 // the default system libraries. Just mimic this for now.
3386 CmdArgs.push_back("-lgcc");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003387
3388 if (Args.hasArg(options::OPT_pthread))
Chris Lattnera2e40212011-02-21 18:36:51 +00003389 CmdArgs.push_back("-lpthread");
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00003390 if (!Args.hasArg(options::OPT_shared))
3391 CmdArgs.push_back("-lc");
3392 CmdArgs.push_back("-lgcc");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003393 }
3394
3395 if (!Args.hasArg(options::OPT_nostdlib) &&
3396 !Args.hasArg(options::OPT_nostartfiles)) {
3397 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00003398 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003399 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003400 else
Chris Lattner38e317d2010-07-07 16:01:42 +00003401 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003402 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003403 }
3404
3405 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003406 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003407 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003408}
Ed Schoutenc66a5a32009-04-02 19:13:12 +00003409
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003410void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003411 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003412 const InputInfoList &Inputs,
3413 const ArgList &Args,
Mike Stump1eb44332009-09-09 15:08:12 +00003414 const char *LinkingOutput) const {
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003415 ArgStringList CmdArgs;
3416
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003417 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3418 // instruct as in the base system to assemble 32-bit code.
3419 if (getToolChain().getArchName() == "i386")
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003420 CmdArgs.push_back("--32");
3421
Michael J. Spencer20249a12010-10-21 03:16:25 +00003422
Eric Christophered734732010-03-02 02:41:08 +00003423 // Set byte order explicitly
3424 if (getToolChain().getArchName() == "mips")
3425 CmdArgs.push_back("-EB");
3426 else if (getToolChain().getArchName() == "mipsel")
3427 CmdArgs.push_back("-EL");
3428
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003429 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3430 options::OPT_Xassembler);
3431
3432 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003433 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003434
3435 for (InputInfoList::const_iterator
3436 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3437 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003438 CmdArgs.push_back(II.getFilename());
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003439 }
3440
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003441 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003442 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003443 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar68a31d42009-03-31 17:45:15 +00003444}
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003445
3446void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003447 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003448 const InputInfoList &Inputs,
3449 const ArgList &Args,
Daniel Dunbara8304f62009-05-02 20:14:53 +00003450 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003451 const Driver &D = getToolChain().getDriver();
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003452 ArgStringList CmdArgs;
3453
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00003454 if (!D.SysRoot.empty())
3455 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
3456
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003457 if (Args.hasArg(options::OPT_static)) {
3458 CmdArgs.push_back("-Bstatic");
3459 } else {
Rafael Espindola65ba55d2010-11-11 02:17:51 +00003460 if (Args.hasArg(options::OPT_rdynamic))
3461 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003462 CmdArgs.push_back("--eh-frame-hdr");
3463 if (Args.hasArg(options::OPT_shared)) {
3464 CmdArgs.push_back("-Bshareable");
3465 } else {
3466 CmdArgs.push_back("-dynamic-linker");
3467 CmdArgs.push_back("/libexec/ld-elf.so.1");
3468 }
3469 }
3470
3471 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3472 // instruct ld in the base system to link 32-bit code.
3473 if (getToolChain().getArchName() == "i386") {
3474 CmdArgs.push_back("-m");
3475 CmdArgs.push_back("elf_i386_fbsd");
3476 }
3477
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003478 if (Output.isFilename()) {
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003479 CmdArgs.push_back("-o");
3480 CmdArgs.push_back(Output.getFilename());
3481 } else {
3482 assert(Output.isNothing() && "Invalid output.");
3483 }
3484
3485 if (!Args.hasArg(options::OPT_nostdlib) &&
3486 !Args.hasArg(options::OPT_nostartfiles)) {
3487 if (!Args.hasArg(options::OPT_shared)) {
Roman Divackyc16bb762011-02-10 16:59:40 +00003488 if (Args.hasArg(options::OPT_pg))
3489 CmdArgs.push_back(Args.MakeArgString(
3490 getToolChain().GetFilePath("gcrt1.o")));
3491 else
3492 CmdArgs.push_back(Args.MakeArgString(
3493 getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003494 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003495 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003496 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003497 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003498 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00003499 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003500 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00003501 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003502 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003503 }
3504 }
3505
3506 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divacky58e5ac92011-03-01 17:53:14 +00003507 const ToolChain::path_list Paths = getToolChain().getFilePaths();
3508 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
3509 i != e; ++i)
3510 CmdArgs.push_back(Args.MakeArgString(llvm::StringRef("-L") + *i));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003511 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3512 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnallc7363772010-08-15 22:58:12 +00003513 Args.AddAllArgs(CmdArgs, options::OPT_s);
3514 Args.AddAllArgs(CmdArgs, options::OPT_t);
3515 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3516 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003517
Daniel Dunbar2008fee2010-09-17 00:24:54 +00003518 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003519
3520 if (!Args.hasArg(options::OPT_nostdlib) &&
3521 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar20022632010-02-17 08:07:51 +00003522 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00003523 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divackyc16bb762011-02-10 16:59:40 +00003524 if (Args.hasArg(options::OPT_pg))
3525 CmdArgs.push_back("-lm_p");
3526 else
3527 CmdArgs.push_back("-lm");
Daniel Dunbar20022632010-02-17 08:07:51 +00003528 }
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003529 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3530 // the default system libraries. Just mimic this for now.
Roman Divackyc16bb762011-02-10 16:59:40 +00003531 if (Args.hasArg(options::OPT_pg))
3532 CmdArgs.push_back("-lgcc_p");
3533 else
3534 CmdArgs.push_back("-lgcc");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003535 if (Args.hasArg(options::OPT_static)) {
3536 CmdArgs.push_back("-lgcc_eh");
Roman Divackyc16bb762011-02-10 16:59:40 +00003537 } else if (Args.hasArg(options::OPT_pg)) {
3538 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003539 } else {
3540 CmdArgs.push_back("--as-needed");
3541 CmdArgs.push_back("-lgcc_s");
3542 CmdArgs.push_back("--no-as-needed");
3543 }
3544
Matt Beaumont-Gay24230262011-02-10 20:35:01 +00003545 if (Args.hasArg(options::OPT_pthread)) {
Roman Divackyc16bb762011-02-10 16:59:40 +00003546 if (Args.hasArg(options::OPT_pg))
3547 CmdArgs.push_back("-lpthread_p");
3548 else
3549 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay24230262011-02-10 20:35:01 +00003550 }
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003551
Roman Divackyc16bb762011-02-10 16:59:40 +00003552 if (Args.hasArg(options::OPT_pg)) {
3553 if (Args.hasArg(options::OPT_shared))
3554 CmdArgs.push_back("-lc");
3555 else
3556 CmdArgs.push_back("-lc_p");
3557 CmdArgs.push_back("-lgcc_p");
3558 } else {
3559 CmdArgs.push_back("-lc");
3560 CmdArgs.push_back("-lgcc");
3561 }
3562
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003563 if (Args.hasArg(options::OPT_static)) {
3564 CmdArgs.push_back("-lgcc_eh");
Roman Divackyc16bb762011-02-10 16:59:40 +00003565 } else if (Args.hasArg(options::OPT_pg)) {
3566 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003567 } else {
3568 CmdArgs.push_back("--as-needed");
3569 CmdArgs.push_back("-lgcc_s");
3570 CmdArgs.push_back("--no-as-needed");
3571 }
3572 }
3573
3574 if (!Args.hasArg(options::OPT_nostdlib) &&
3575 !Args.hasArg(options::OPT_nostartfiles)) {
3576 if (!Args.hasArg(options::OPT_shared))
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003577 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00003578 "crtend.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003579 else
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003580 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00003581 "crtendS.o")));
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003582 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00003583 "crtn.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003584 }
3585
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003586 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003587 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003588 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00003589}
Daniel Dunbar11e1b402009-05-02 18:28:39 +00003590
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003591void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3592 const InputInfo &Output,
3593 const InputInfoList &Inputs,
3594 const ArgList &Args,
3595 const char *LinkingOutput) const {
3596 ArgStringList CmdArgs;
3597
3598 // When building 32-bit code on NetBSD/amd64, we have to explicitly
3599 // instruct as in the base system to assemble 32-bit code.
3600 if (getToolChain().getArchName() == "i386")
3601 CmdArgs.push_back("--32");
3602
3603
3604 // Set byte order explicitly
3605 if (getToolChain().getArchName() == "mips")
3606 CmdArgs.push_back("-EB");
3607 else if (getToolChain().getArchName() == "mipsel")
3608 CmdArgs.push_back("-EL");
3609
3610 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3611 options::OPT_Xassembler);
3612
3613 CmdArgs.push_back("-o");
3614 CmdArgs.push_back(Output.getFilename());
3615
3616 for (InputInfoList::const_iterator
3617 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3618 const InputInfo &II = *it;
3619 CmdArgs.push_back(II.getFilename());
3620 }
3621
Joerg Sonnenberger10c64352011-03-21 14:01:40 +00003622 const char *Exec = Args.MakeArgString(FindTargetProgramPath(getToolChain(),
3623 "as"));
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003624 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3625}
3626
3627void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3628 const InputInfo &Output,
3629 const InputInfoList &Inputs,
3630 const ArgList &Args,
3631 const char *LinkingOutput) const {
3632 const Driver &D = getToolChain().getDriver();
3633 ArgStringList CmdArgs;
3634
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00003635 if (!D.SysRoot.empty())
3636 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
3637
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003638 if (Args.hasArg(options::OPT_static)) {
3639 CmdArgs.push_back("-Bstatic");
3640 } else {
3641 if (Args.hasArg(options::OPT_rdynamic))
3642 CmdArgs.push_back("-export-dynamic");
3643 CmdArgs.push_back("--eh-frame-hdr");
3644 if (Args.hasArg(options::OPT_shared)) {
3645 CmdArgs.push_back("-Bshareable");
3646 } else {
3647 CmdArgs.push_back("-dynamic-linker");
3648 CmdArgs.push_back("/libexec/ld.elf_so");
3649 }
3650 }
3651
3652 // When building 32-bit code on NetBSD/amd64, we have to explicitly
3653 // instruct ld in the base system to link 32-bit code.
3654 if (getToolChain().getArchName() == "i386") {
3655 CmdArgs.push_back("-m");
3656 CmdArgs.push_back("elf_i386");
3657 }
3658
3659 if (Output.isFilename()) {
3660 CmdArgs.push_back("-o");
3661 CmdArgs.push_back(Output.getFilename());
3662 } else {
3663 assert(Output.isNothing() && "Invalid output.");
3664 }
3665
3666 if (!Args.hasArg(options::OPT_nostdlib) &&
3667 !Args.hasArg(options::OPT_nostartfiles)) {
3668 if (!Args.hasArg(options::OPT_shared)) {
3669 CmdArgs.push_back(Args.MakeArgString(
3670 getToolChain().GetFilePath("crt0.o")));
3671 CmdArgs.push_back(Args.MakeArgString(
3672 getToolChain().GetFilePath("crti.o")));
3673 CmdArgs.push_back(Args.MakeArgString(
3674 getToolChain().GetFilePath("crtbegin.o")));
3675 } else {
3676 CmdArgs.push_back(Args.MakeArgString(
3677 getToolChain().GetFilePath("crti.o")));
3678 CmdArgs.push_back(Args.MakeArgString(
3679 getToolChain().GetFilePath("crtbeginS.o")));
3680 }
3681 }
3682
3683 Args.AddAllArgs(CmdArgs, options::OPT_L);
3684 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3685 Args.AddAllArgs(CmdArgs, options::OPT_e);
3686 Args.AddAllArgs(CmdArgs, options::OPT_s);
3687 Args.AddAllArgs(CmdArgs, options::OPT_t);
3688 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3689 Args.AddAllArgs(CmdArgs, options::OPT_r);
3690
3691 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3692
3693 if (!Args.hasArg(options::OPT_nostdlib) &&
3694 !Args.hasArg(options::OPT_nodefaultlibs)) {
3695 if (D.CCCIsCXX) {
3696 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3697 CmdArgs.push_back("-lm");
3698 }
3699 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3700 // the default system libraries. Just mimic this for now.
3701 CmdArgs.push_back("-lgcc");
3702 if (Args.hasArg(options::OPT_static)) {
3703 CmdArgs.push_back("-lgcc_eh");
3704 } else {
3705 CmdArgs.push_back("--as-needed");
3706 CmdArgs.push_back("-lgcc_s");
3707 CmdArgs.push_back("--no-as-needed");
3708 }
3709
3710 if (Args.hasArg(options::OPT_pthread))
3711 CmdArgs.push_back("-lpthread");
3712 CmdArgs.push_back("-lc");
3713
3714 CmdArgs.push_back("-lgcc");
3715 if (Args.hasArg(options::OPT_static)) {
3716 CmdArgs.push_back("-lgcc_eh");
3717 } else {
3718 CmdArgs.push_back("--as-needed");
3719 CmdArgs.push_back("-lgcc_s");
3720 CmdArgs.push_back("--no-as-needed");
3721 }
3722 }
3723
3724 if (!Args.hasArg(options::OPT_nostdlib) &&
3725 !Args.hasArg(options::OPT_nostartfiles)) {
3726 if (!Args.hasArg(options::OPT_shared))
3727 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
3728 "crtend.o")));
3729 else
3730 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
3731 "crtendS.o")));
3732 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
3733 "crtn.o")));
3734 }
3735
Joerg Sonnenberger10c64352011-03-21 14:01:40 +00003736 const char *Exec = Args.MakeArgString(FindTargetProgramPath(getToolChain(),
3737 "ld"));
Benjamin Kramer8e50a962011-02-02 18:59:27 +00003738 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3739}
3740
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00003741void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3742 const InputInfo &Output,
3743 const InputInfoList &Inputs,
3744 const ArgList &Args,
3745 const char *LinkingOutput) const {
3746 ArgStringList CmdArgs;
3747
3748 // Add --32/--64 to make sure we get the format we want.
3749 // This is incomplete
3750 if (getToolChain().getArch() == llvm::Triple::x86) {
3751 CmdArgs.push_back("--32");
3752 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
3753 CmdArgs.push_back("--64");
3754 } else if (getToolChain().getArch() == llvm::Triple::arm) {
3755 llvm::StringRef MArch = getToolChain().getArchName();
3756 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
3757 CmdArgs.push_back("-mfpu=neon");
3758 }
3759
3760 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3761 options::OPT_Xassembler);
3762
3763 CmdArgs.push_back("-o");
3764 CmdArgs.push_back(Output.getFilename());
3765
3766 for (InputInfoList::const_iterator
3767 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3768 const InputInfo &II = *it;
3769 CmdArgs.push_back(II.getFilename());
3770 }
3771
3772 const char *Exec =
3773 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3774 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3775}
3776
Rafael Espindolac1da9812010-11-07 20:14:31 +00003777void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
3778 const InputInfo &Output,
3779 const InputInfoList &Inputs,
3780 const ArgList &Args,
3781 const char *LinkingOutput) const {
3782 const toolchains::Linux& ToolChain =
3783 static_cast<const toolchains::Linux&>(getToolChain());
3784 const Driver &D = ToolChain.getDriver();
3785 ArgStringList CmdArgs;
3786
Rafael Espindola26f14c32010-11-15 18:28:16 +00003787 // Silence warning for "clang -g foo.o -o foo"
3788 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00003789 // and "clang -emit-llvm foo.o -o foo"
3790 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindola7f6458b2010-11-17 20:37:10 +00003791 // and for "clang -g foo.o -o foo". Other warning options are already
3792 // handled somewhere else.
3793 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindola26f14c32010-11-15 18:28:16 +00003794
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00003795 if (!D.SysRoot.empty())
3796 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac1da9812010-11-07 20:14:31 +00003797
Rafael Espindolafdda1712010-11-17 22:26:15 +00003798 if (Args.hasArg(options::OPT_pie))
3799 CmdArgs.push_back("-pie");
3800
Rafael Espindoladc1b76d2010-11-07 22:57:16 +00003801 if (Args.hasArg(options::OPT_rdynamic))
3802 CmdArgs.push_back("-export-dynamic");
3803
Rafael Espindolae0e6d3b2010-11-11 19:34:42 +00003804 if (Args.hasArg(options::OPT_s))
3805 CmdArgs.push_back("-s");
3806
Rafael Espindolac1da9812010-11-07 20:14:31 +00003807 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
3808 e = ToolChain.ExtraOpts.end();
3809 i != e; ++i)
3810 CmdArgs.push_back(i->c_str());
3811
3812 if (!Args.hasArg(options::OPT_static)) {
3813 CmdArgs.push_back("--eh-frame-hdr");
3814 }
3815
3816 CmdArgs.push_back("-m");
3817 if (ToolChain.getArch() == llvm::Triple::x86)
3818 CmdArgs.push_back("elf_i386");
Douglas Gregorf0594d82011-03-06 19:11:49 +00003819 else if (ToolChain.getArch() == llvm::Triple::arm
3820 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00003821 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43ac2972011-04-05 22:04:27 +00003822 else if (ToolChain.getArch() == llvm::Triple::ppc)
3823 CmdArgs.push_back("elf32ppclinux");
3824 else if (ToolChain.getArch() == llvm::Triple::ppc64)
3825 CmdArgs.push_back("elf64ppc");
Rafael Espindolac1da9812010-11-07 20:14:31 +00003826 else
3827 CmdArgs.push_back("elf_x86_64");
3828
3829 if (Args.hasArg(options::OPT_static)) {
Douglas Gregorf0594d82011-03-06 19:11:49 +00003830 if (ToolChain.getArch() == llvm::Triple::arm
3831 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00003832 CmdArgs.push_back("-Bstatic");
3833 else
3834 CmdArgs.push_back("-static");
3835 } else if (Args.hasArg(options::OPT_shared)) {
3836 CmdArgs.push_back("-shared");
3837 }
3838
3839 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregorf0594d82011-03-06 19:11:49 +00003840 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac1da9812010-11-07 20:14:31 +00003841 (!Args.hasArg(options::OPT_static) &&
3842 !Args.hasArg(options::OPT_shared))) {
3843 CmdArgs.push_back("-dynamic-linker");
3844 if (ToolChain.getArch() == llvm::Triple::x86)
3845 CmdArgs.push_back("/lib/ld-linux.so.2");
Douglas Gregorf0594d82011-03-06 19:11:49 +00003846 else if (ToolChain.getArch() == llvm::Triple::arm ||
3847 ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00003848 CmdArgs.push_back("/lib/ld-linux.so.3");
Ted Kremenek43ac2972011-04-05 22:04:27 +00003849 else if (ToolChain.getArch() == llvm::Triple::ppc)
Chris Lattner09f43ed2011-04-11 21:15:37 +00003850 CmdArgs.push_back("/lib/ld.so.1");
Ted Kremenek43ac2972011-04-05 22:04:27 +00003851 else if (ToolChain.getArch() == llvm::Triple::ppc64)
Chris Lattner09f43ed2011-04-11 21:15:37 +00003852 CmdArgs.push_back("/lib64/ld64.so.1");
Rafael Espindolac1da9812010-11-07 20:14:31 +00003853 else
3854 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
3855 }
3856
3857 CmdArgs.push_back("-o");
3858 CmdArgs.push_back(Output.getFilename());
3859
Rafael Espindola49c64fd2010-12-01 01:52:43 +00003860 if (!Args.hasArg(options::OPT_nostdlib) &&
3861 !Args.hasArg(options::OPT_nostartfiles)) {
Rafael Espindolafdda1712010-11-17 22:26:15 +00003862 const char *crt1 = NULL;
3863 if (!Args.hasArg(options::OPT_shared)){
3864 if (Args.hasArg(options::OPT_pie))
3865 crt1 = "Scrt1.o";
3866 else
3867 crt1 = "crt1.o";
3868 }
3869 if (crt1)
3870 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac1da9812010-11-07 20:14:31 +00003871
Rafael Espindola89414b32010-11-12 03:00:39 +00003872 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
Rafael Espindolac1da9812010-11-07 20:14:31 +00003873
Rafael Espindola89414b32010-11-12 03:00:39 +00003874 const char *crtbegin;
3875 if (Args.hasArg(options::OPT_static))
3876 crtbegin = "crtbeginT.o";
Rafael Espindolafdda1712010-11-17 22:26:15 +00003877 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Rafael Espindola89414b32010-11-12 03:00:39 +00003878 crtbegin = "crtbeginS.o";
3879 else
3880 crtbegin = "crtbegin.o";
3881 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
3882 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00003883
3884 Args.AddAllArgs(CmdArgs, options::OPT_L);
3885
3886 const ToolChain::path_list Paths = ToolChain.getFilePaths();
3887
Roman Divacky58e5ac92011-03-01 17:53:14 +00003888 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
3889 i != e; ++i)
3890 CmdArgs.push_back(Args.MakeArgString(llvm::StringRef("-L") + *i));
Rafael Espindolac1da9812010-11-07 20:14:31 +00003891
3892 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
3893
Rafael Espindola89414b32010-11-12 03:00:39 +00003894 if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) {
Rafael Espindolac1da9812010-11-07 20:14:31 +00003895 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
3896 CmdArgs.push_back("-lm");
3897 }
3898
3899 if (Args.hasArg(options::OPT_static))
3900 CmdArgs.push_back("--start-group");
3901
Rafael Espindola89414b32010-11-12 03:00:39 +00003902 if (!Args.hasArg(options::OPT_nostdlib)) {
3903 if (!D.CCCIsCXX)
Rafael Espindolac1da9812010-11-07 20:14:31 +00003904 CmdArgs.push_back("-lgcc");
Rafael Espindola89414b32010-11-12 03:00:39 +00003905
3906 if (Args.hasArg(options::OPT_static)) {
3907 if (D.CCCIsCXX)
3908 CmdArgs.push_back("-lgcc");
3909 } else {
3910 if (!D.CCCIsCXX)
3911 CmdArgs.push_back("--as-needed");
3912 CmdArgs.push_back("-lgcc_s");
3913 if (!D.CCCIsCXX)
3914 CmdArgs.push_back("--no-as-needed");
3915 }
3916
3917 if (Args.hasArg(options::OPT_static))
3918 CmdArgs.push_back("-lgcc_eh");
3919 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
3920 CmdArgs.push_back("-lgcc");
3921
3922 if (Args.hasArg(options::OPT_pthread) ||
3923 Args.hasArg(options::OPT_pthreads))
3924 CmdArgs.push_back("-lpthread");
3925
3926 CmdArgs.push_back("-lc");
3927
3928 if (Args.hasArg(options::OPT_static))
3929 CmdArgs.push_back("--end-group");
3930 else {
3931 if (!D.CCCIsCXX)
3932 CmdArgs.push_back("-lgcc");
3933
3934 if (!D.CCCIsCXX)
3935 CmdArgs.push_back("--as-needed");
3936 CmdArgs.push_back("-lgcc_s");
3937 if (!D.CCCIsCXX)
3938 CmdArgs.push_back("--no-as-needed");
3939
3940 if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
3941 CmdArgs.push_back("-lgcc");
3942 }
3943
Rafael Espindolafdda1712010-11-17 22:26:15 +00003944
Rafael Espindola49c64fd2010-12-01 01:52:43 +00003945 if (!Args.hasArg(options::OPT_nostartfiles)) {
3946 const char *crtend;
3947 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
3948 crtend = "crtendS.o";
3949 else
3950 crtend = "crtend.o";
Rafael Espindola89414b32010-11-12 03:00:39 +00003951
Rafael Espindola49c64fd2010-12-01 01:52:43 +00003952 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
3953 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
3954 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00003955 }
3956
Rafael Espindolac1da9812010-11-07 20:14:31 +00003957 if (Args.hasArg(options::OPT_use_gold_plugin)) {
3958 CmdArgs.push_back("-plugin");
3959 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
3960 CmdArgs.push_back(Args.MakeArgString(Plugin));
3961 }
3962
3963 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
3964}
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00003965
Chris Lattner38e317d2010-07-07 16:01:42 +00003966void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003967 const InputInfo &Output,
3968 const InputInfoList &Inputs,
3969 const ArgList &Args,
3970 const char *LinkingOutput) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00003971 ArgStringList CmdArgs;
3972
3973 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3974 options::OPT_Xassembler);
3975
3976 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003977 CmdArgs.push_back(Output.getFilename());
Chris Lattner38e317d2010-07-07 16:01:42 +00003978
3979 for (InputInfoList::const_iterator
3980 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3981 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003982 CmdArgs.push_back(II.getFilename());
Chris Lattner38e317d2010-07-07 16:01:42 +00003983 }
3984
3985 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00003986 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003987 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner38e317d2010-07-07 16:01:42 +00003988}
3989
3990void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003991 const InputInfo &Output,
3992 const InputInfoList &Inputs,
3993 const ArgList &Args,
3994 const char *LinkingOutput) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00003995 const Driver &D = getToolChain().getDriver();
3996 ArgStringList CmdArgs;
3997
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003998 if (Output.isFilename()) {
Chris Lattner38e317d2010-07-07 16:01:42 +00003999 CmdArgs.push_back("-o");
4000 CmdArgs.push_back(Output.getFilename());
4001 } else {
4002 assert(Output.isNothing() && "Invalid output.");
4003 }
4004
4005 if (!Args.hasArg(options::OPT_nostdlib) &&
4006 !Args.hasArg(options::OPT_nostartfiles))
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004007 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00004008 "/usr/gnu/lib/crtso.o")));
4009
4010 Args.AddAllArgs(CmdArgs, options::OPT_L);
4011 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4012 Args.AddAllArgs(CmdArgs, options::OPT_e);
4013
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004014 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner38e317d2010-07-07 16:01:42 +00004015
4016 if (!Args.hasArg(options::OPT_nostdlib) &&
4017 !Args.hasArg(options::OPT_nodefaultlibs)) {
4018 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00004019 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner38e317d2010-07-07 16:01:42 +00004020 CmdArgs.push_back("-lm");
4021 }
4022
4023 if (Args.hasArg(options::OPT_pthread))
4024 CmdArgs.push_back("-lpthread");
4025 CmdArgs.push_back("-lc");
4026 CmdArgs.push_back("-lgcc");
4027 CmdArgs.push_back("-L/usr/gnu/lib");
4028 // FIXME: fill in the correct search path for the final
4029 // support libraries.
4030 CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
4031 }
4032
4033 if (!Args.hasArg(options::OPT_nostdlib) &&
4034 !Args.hasArg(options::OPT_nostartfiles)) {
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004035 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner38e317d2010-07-07 16:01:42 +00004036 "/usr/gnu/lib/libend.a")));
4037 }
4038
4039 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004040 Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004041 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner38e317d2010-07-07 16:01:42 +00004042}
4043
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004044/// DragonFly Tools
4045
4046// For now, DragonFly Assemble does just about the same as for
4047// FreeBSD, but this may change soon.
4048void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004049 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00004050 const InputInfoList &Inputs,
4051 const ArgList &Args,
4052 const char *LinkingOutput) const {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004053 ArgStringList CmdArgs;
4054
4055 // When building 32-bit code on DragonFly/pc64, we have to explicitly
4056 // instruct as in the base system to assemble 32-bit code.
4057 if (getToolChain().getArchName() == "i386")
4058 CmdArgs.push_back("--32");
4059
4060 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4061 options::OPT_Xassembler);
4062
4063 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004064 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004065
4066 for (InputInfoList::const_iterator
4067 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4068 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004069 CmdArgs.push_back(II.getFilename());
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004070 }
4071
4072 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004073 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004074 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004075}
4076
4077void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004078 const InputInfo &Output,
4079 const InputInfoList &Inputs,
4080 const ArgList &Args,
4081 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00004082 const Driver &D = getToolChain().getDriver();
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004083 ArgStringList CmdArgs;
4084
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00004085 if (!D.SysRoot.empty())
4086 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4087
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004088 if (Args.hasArg(options::OPT_static)) {
4089 CmdArgs.push_back("-Bstatic");
4090 } else {
4091 if (Args.hasArg(options::OPT_shared))
4092 CmdArgs.push_back("-Bshareable");
4093 else {
4094 CmdArgs.push_back("-dynamic-linker");
4095 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
4096 }
4097 }
4098
4099 // When building 32-bit code on DragonFly/pc64, we have to explicitly
4100 // instruct ld in the base system to link 32-bit code.
4101 if (getToolChain().getArchName() == "i386") {
4102 CmdArgs.push_back("-m");
4103 CmdArgs.push_back("elf_i386");
4104 }
4105
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004106 if (Output.isFilename()) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004107 CmdArgs.push_back("-o");
4108 CmdArgs.push_back(Output.getFilename());
4109 } else {
4110 assert(Output.isNothing() && "Invalid output.");
4111 }
4112
4113 if (!Args.hasArg(options::OPT_nostdlib) &&
4114 !Args.hasArg(options::OPT_nostartfiles)) {
4115 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00004116 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004117 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004118 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004119 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004120 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004121 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004122 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00004123 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004124 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004125 CmdArgs.push_back(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004126 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004127 }
4128 }
4129
4130 Args.AddAllArgs(CmdArgs, options::OPT_L);
4131 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4132 Args.AddAllArgs(CmdArgs, options::OPT_e);
4133
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004134 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004135
4136 if (!Args.hasArg(options::OPT_nostdlib) &&
4137 !Args.hasArg(options::OPT_nodefaultlibs)) {
4138 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
4139 // rpaths
4140 CmdArgs.push_back("-L/usr/lib/gcc41");
4141
4142 if (!Args.hasArg(options::OPT_static)) {
4143 CmdArgs.push_back("-rpath");
4144 CmdArgs.push_back("/usr/lib/gcc41");
4145
4146 CmdArgs.push_back("-rpath-link");
4147 CmdArgs.push_back("/usr/lib/gcc41");
4148
4149 CmdArgs.push_back("-rpath");
4150 CmdArgs.push_back("/usr/lib");
4151
4152 CmdArgs.push_back("-rpath-link");
4153 CmdArgs.push_back("/usr/lib");
4154 }
4155
Rafael Espindola405861d2010-07-20 12:59:03 +00004156 if (D.CCCIsCXX) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00004157 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola405861d2010-07-20 12:59:03 +00004158 CmdArgs.push_back("-lm");
4159 }
4160
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004161 if (Args.hasArg(options::OPT_shared)) {
4162 CmdArgs.push_back("-lgcc_pic");
4163 } else {
4164 CmdArgs.push_back("-lgcc");
4165 }
4166
4167
4168 if (Args.hasArg(options::OPT_pthread))
Mike Stump4d63f8b2009-10-31 20:11:46 +00004169 CmdArgs.push_back("-lpthread");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004170
4171 if (!Args.hasArg(options::OPT_nolibc)) {
4172 CmdArgs.push_back("-lc");
4173 }
4174
4175 if (Args.hasArg(options::OPT_shared)) {
4176 CmdArgs.push_back("-lgcc_pic");
4177 } else {
4178 CmdArgs.push_back("-lgcc");
4179 }
4180 }
4181
4182 if (!Args.hasArg(options::OPT_nostdlib) &&
4183 !Args.hasArg(options::OPT_nostartfiles)) {
4184 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00004185 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004186 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004187 else
Chris Lattner38e317d2010-07-07 16:01:42 +00004188 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004189 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00004190 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004191 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004192 }
4193
4194 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004195 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004196 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00004197}
Michael J. Spencerff58e362010-08-21 21:55:07 +00004198
4199void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
4200 const InputInfo &Output,
4201 const InputInfoList &Inputs,
4202 const ArgList &Args,
4203 const char *LinkingOutput) const {
Michael J. Spencerff58e362010-08-21 21:55:07 +00004204 ArgStringList CmdArgs;
4205
4206 if (Output.isFilename()) {
Daniel Dunbare5a37f42010-09-17 00:45:02 +00004207 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
4208 Output.getFilename()));
Michael J. Spencerff58e362010-08-21 21:55:07 +00004209 } else {
4210 assert(Output.isNothing() && "Invalid output.");
4211 }
4212
4213 if (!Args.hasArg(options::OPT_nostdlib) &&
4214 !Args.hasArg(options::OPT_nostartfiles)) {
4215 CmdArgs.push_back("-defaultlib:libcmt");
4216 }
4217
4218 CmdArgs.push_back("-nologo");
4219
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004220 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Michael J. Spencerff58e362010-08-21 21:55:07 +00004221
4222 const char *Exec =
Daniel Dunbar2008fee2010-09-17 00:24:54 +00004223 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerff58e362010-08-21 21:55:07 +00004224 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4225}