blob: cdaea98587654ee69988bfb75679bd6656eec899 [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar1a093d22009-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 Dunbara2aedc62009-03-18 10:01:51 +000012#include "clang/Driver/Action.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000013#include "clang/Driver/Arg.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000014#include "clang/Driver/ArgList.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000015#include "clang/Driver/Driver.h"
16#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000017#include "clang/Driver/Compilation.h"
18#include "clang/Driver/Job.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000019#include "clang/Driver/HostInfo.h"
20#include "clang/Driver/Option.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000021#include "clang/Driver/Options.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000022#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000023#include "clang/Driver/Util.h"
24
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000026#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000027#include "llvm/ADT/Twine.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000028#include "llvm/Support/Format.h"
29#include "llvm/Support/raw_ostream.h"
Daniel Dunbare13ada62009-11-14 22:04:54 +000030#include "llvm/System/Host.h"
Daniel Dunbar2c978472009-11-04 06:24:47 +000031#include "llvm/System/Process.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000032
33#include "InputInfo.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000034#include "ToolChains.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000035
Daniel Dunbar1a093d22009-03-18 06:00:36 +000036using namespace clang::driver;
37using namespace clang::driver::tools;
38
Daniel Dunbar64198ef2009-09-10 01:21:05 +000039/// CheckPreprocessingOptions - Perform some validation of preprocessing
40/// arguments that is shared with gcc.
41static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
42 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
43 if (!Args.hasArg(options::OPT_E))
44 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
45 << A->getAsString(Args) << "-E";
46}
47
Daniel Dunbar4eadb602009-09-10 01:21:12 +000048/// CheckCodeGenerationOptions - Perform some validation of code generation
49/// arguments that is shared with gcc.
50static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
51 // In gcc, only ARM checks this, but it seems reasonable to check universally.
52 if (Args.hasArg(options::OPT_static))
53 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
54 options::OPT_mdynamic_no_pic))
55 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
56 << A->getAsString(Args) << "-static";
57}
58
Chris Lattnerbf2803f2010-03-29 17:55:58 +000059// Quote target names for inclusion in GNU Make dependency files.
60// Only the characters '$', '#', ' ', '\t' are quoted.
61static void QuoteTarget(llvm::StringRef Target,
62 llvm::SmallVectorImpl<char> &Res) {
63 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
64 switch (Target[i]) {
65 case ' ':
66 case '\t':
67 // Escape the preceding backslashes
68 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
69 Res.push_back('\\');
70
71 // Escape the space/tab
72 Res.push_back('\\');
73 break;
74 case '$':
75 Res.push_back('$');
76 break;
77 case '#':
78 Res.push_back('\\');
79 break;
80 default:
81 break;
82 }
83
84 Res.push_back(Target[i]);
85 }
86}
87
Daniel Dunbar54423b22010-09-17 00:24:54 +000088static void AddLinkerInputs(const ToolChain &TC,
89 const InputInfoList &Inputs, const ArgList &Args,
90 ArgStringList &CmdArgs) {
91 const Driver &D = TC.getDriver();
92
93 for (InputInfoList::const_iterator
94 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
95 const InputInfo &II = *it;
96
97 if (!TC.HasNativeLLVMSupport()) {
98 // Don't try to pass LLVM inputs unless we have native support.
99 if (II.getType() == types::TY_LLVM_IR ||
100 II.getType() == types::TY_LTO_IR ||
101 II.getType() == types::TY_LLVM_BC ||
102 II.getType() == types::TY_LTO_BC)
103 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
104 << TC.getTripleString();
105 }
106
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000107 // Add filenames immediately.
108 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000109 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000110 continue;
111 }
112
113 // Otherwise, this is a linker input argument.
114 const Arg &A = II.getInputArg();
115
116 // Handle reserved library options.
117 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000118 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000119 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
120 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000121 } else
122 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000123 }
124}
125
Mike Stump11289f42009-09-09 15:08:12 +0000126void Clang::AddPreprocessingOptions(const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000127 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000128 ArgStringList &CmdArgs,
129 const InputInfo &Output,
130 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000131 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000132
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000133 CheckPreprocessingOptions(D, Args);
134
135 Args.AddLastArg(CmdArgs, options::OPT_C);
136 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000137
138 // Handle dependency file generation.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000139 if ((A = Args.getLastArg(options::OPT_M)) ||
140 (A = Args.getLastArg(options::OPT_MM)) ||
141 (A = Args.getLastArg(options::OPT_MD)) ||
142 (A = Args.getLastArg(options::OPT_MMD))) {
143 // Determine the output location.
144 const char *DepFile;
145 if (Output.getType() == types::TY_Dependencies) {
Daniel Dunbarb440f562010-08-02 02:38:21 +0000146 DepFile = Output.getFilename();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000147 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
148 DepFile = MF->getValue(Args);
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000149 } else if (A->getOption().matches(options::OPT_M) ||
150 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000151 DepFile = "-";
152 } else {
153 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
154 }
155 CmdArgs.push_back("-dependency-file");
156 CmdArgs.push_back(DepFile);
157
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000158 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000159 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
160 const char *DepTarget;
161
162 // If user provided -o, that is the dependency target, except
163 // when we are only generating a dependency file.
164 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
165 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
166 DepTarget = OutputOpt->getValue(Args);
167 } else {
168 // Otherwise derive from the base input.
169 //
170 // FIXME: This should use the computed output file location.
171 llvm::sys::Path P(Inputs[0].getBaseInput());
172
173 P.eraseSuffix();
174 P.appendSuffix("o");
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +0000175 DepTarget = Args.MakeArgString(P.getLast());
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000176 }
177
178 CmdArgs.push_back("-MT");
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000179 llvm::SmallString<128> Quoted;
180 QuoteTarget(DepTarget, Quoted);
181 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000182 }
183
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000184 if (A->getOption().matches(options::OPT_M) ||
185 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000186 CmdArgs.push_back("-sys-header-deps");
187 }
188
189 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000190
191 // Convert all -MQ <target> args to -MT <quoted target>
192 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
193 options::OPT_MQ),
194 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000195 const Arg *A = *it;
196 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000197
Daniel Dunbara442fd52010-06-11 22:00:13 +0000198 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000199 CmdArgs.push_back("-MT");
200 llvm::SmallString<128> Quoted;
Daniel Dunbara442fd52010-06-11 22:00:13 +0000201 QuoteTarget(A->getValue(Args), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000202 CmdArgs.push_back(Args.MakeArgString(Quoted));
203
204 // -MT flag - no change
205 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000206 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000207 }
208 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000209
Douglas Gregor111af7d2009-04-18 00:34:01 +0000210 // Add -i* options, and automatically translate to
211 // -include-pch/-include-pth for transparent PCH support. It's
212 // wonky, but we include looking for .gch so we can support seamless
213 // replacement into a build system already set up to be generating
214 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000215 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000216 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
217 ie = Args.filtered_end(); it != ie; ++it) {
218 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000219
220 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000221 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
222 RenderedImplicitInclude = true;
223
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000224 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000225 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000226
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000227 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000228 bool FoundPCH = false;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000229 llvm::sys::Path P(A->getValue(Args));
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000230 if (UsePCH) {
Douglas Gregor111af7d2009-04-18 00:34:01 +0000231 P.appendSuffix("pch");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000232 if (P.exists())
Douglas Gregor111af7d2009-04-18 00:34:01 +0000233 FoundPCH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000234 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000235 P.eraseSuffix();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000236 }
237
Douglas Gregor111af7d2009-04-18 00:34:01 +0000238 if (!FoundPCH) {
239 P.appendSuffix("pth");
Mike Stump11289f42009-09-09 15:08:12 +0000240 if (P.exists())
Douglas Gregor111af7d2009-04-18 00:34:01 +0000241 FoundPTH = true;
242 else
243 P.eraseSuffix();
Mike Stump11289f42009-09-09 15:08:12 +0000244 }
245
Douglas Gregor111af7d2009-04-18 00:34:01 +0000246 if (!FoundPCH && !FoundPTH) {
247 P.appendSuffix("gch");
248 if (P.exists()) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000249 FoundPCH = UsePCH;
250 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000251 }
Mike Stump11289f42009-09-09 15:08:12 +0000252 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000253 P.eraseSuffix();
254 }
255
256 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000257 if (IsFirstImplicitInclude) {
258 A->claim();
259 if (UsePCH)
260 CmdArgs.push_back("-include-pch");
261 else
262 CmdArgs.push_back("-include-pth");
263 CmdArgs.push_back(Args.MakeArgString(P.str()));
264 continue;
265 } else {
266 // Ignore the PCH if not first on command line and emit warning.
267 D.Diag(clang::diag::warn_drv_pch_not_first_include)
268 << P.str() << A->getAsString(Args);
269 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000270 }
271 }
272
273 // Not translated, render as usual.
274 A->claim();
275 A->render(Args, CmdArgs);
276 }
277
278 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
279 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
280
Daniel Dunbarbf11f792010-09-14 23:12:35 +0000281 // Add C++ include arguments, if needed.
282 types::ID InputType = Inputs[0].getType();
283 if (types::isCXX(InputType))
284 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
285
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000286 // Add -Wp, and -Xassembler if using the preprocessor.
287
288 // FIXME: There is a very unfortunate problem here, some troubled
289 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
290 // really support that we would have to parse and then translate
291 // those options. :(
292 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
293 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000294
295 // -I- is a deprecated GCC feature, reject it.
296 if (Arg *A = Args.getLastArg(options::OPT_I_))
297 D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000298
299 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
300 // -isysroot to the CC1 invocation.
301 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
302 if (!Args.hasArg(options::OPT_isysroot)) {
303 CmdArgs.push_back("-isysroot");
304 CmdArgs.push_back(A->getValue(Args));
305 }
306 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000307}
308
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000309/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targetting.
310//
311// FIXME: tblgen this.
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000312static const char *getARMTargetCPU(const ArgList &Args,
313 const llvm::Triple &Triple) {
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000314 // FIXME: Warn on inconsistent use of -mcpu and -march.
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000315
316 // If we have -mcpu=, use that.
317 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
318 return A->getValue(Args);
319
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000320 llvm::StringRef MArch;
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000321 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000322 // Otherwise, if we have -march= choose the base CPU for that arch.
323 MArch = A->getValue(Args);
324 } else {
325 // Otherwise, use the Arch from the triple.
326 MArch = Triple.getArchName();
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000327 }
328
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000329 if (MArch == "armv2" || MArch == "armv2a")
330 return "arm2";
331 if (MArch == "armv3")
332 return "arm6";
333 if (MArch == "armv3m")
334 return "arm7m";
335 if (MArch == "armv4" || MArch == "armv4t")
336 return "arm7tdmi";
337 if (MArch == "armv5" || MArch == "armv5t")
338 return "arm10tdmi";
339 if (MArch == "armv5e" || MArch == "armv5te")
340 return "arm1026ejs";
341 if (MArch == "armv5tej")
342 return "arm926ej-s";
343 if (MArch == "armv6" || MArch == "armv6k")
344 return "arm1136jf-s";
345 if (MArch == "armv6j")
346 return "arm1136j-s";
347 if (MArch == "armv6z" || MArch == "armv6zk")
348 return "arm1176jzf-s";
349 if (MArch == "armv6t2")
350 return "arm1156t2-s";
351 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
352 return "cortex-a8";
353 if (MArch == "armv7r" || MArch == "armv7-r")
354 return "cortex-r4";
355 if (MArch == "armv7m" || MArch == "armv7-m")
356 return "cortex-m3";
357 if (MArch == "ep9312")
358 return "ep9312";
359 if (MArch == "iwmmxt")
360 return "iwmmxt";
361 if (MArch == "xscale")
362 return "xscale";
363
364 // If all else failed, return the most base CPU LLVM supports.
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000365 return "arm7tdmi";
366}
367
Daniel Dunbarf492c922009-09-10 22:59:51 +0000368/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000369/// CPU.
370//
371// FIXME: This is redundant with -mcpu, why does LLVM use this.
372// FIXME: tblgen this, or kill it!
Daniel Dunbarf492c922009-09-10 22:59:51 +0000373static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) {
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000374 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" ||
375 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" ||
376 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" ||
377 CPU == "arm940t" || CPU == "ep9312")
Daniel Dunbarf492c922009-09-10 22:59:51 +0000378 return "v4t";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000379
380 if (CPU == "arm10tdmi" || CPU == "arm1020t")
Daniel Dunbarf492c922009-09-10 22:59:51 +0000381 return "v5";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000382
383 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" ||
384 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" ||
385 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" ||
386 CPU == "iwmmxt")
Daniel Dunbarf492c922009-09-10 22:59:51 +0000387 return "v5e";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000388
389 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" ||
390 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore")
Daniel Dunbarf492c922009-09-10 22:59:51 +0000391 return "v6";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000392
393 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s")
Daniel Dunbarf492c922009-09-10 22:59:51 +0000394 return "v6t2";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000395
396 if (CPU == "cortex-a8" || CPU == "cortex-a9")
Daniel Dunbarf492c922009-09-10 22:59:51 +0000397 return "v7";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000398
Daniel Dunbarf492c922009-09-10 22:59:51 +0000399 return "";
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000400}
401
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000402// FIXME: Move to target hook.
403static bool isSignedCharDefault(const llvm::Triple &Triple) {
404 switch (Triple.getArch()) {
405 default:
406 return true;
407
408 case llvm::Triple::ppc:
409 case llvm::Triple::ppc64:
410 if (Triple.getOS() == llvm::Triple::Darwin)
411 return true;
412 return false;
413
414 case llvm::Triple::systemz:
415 return false;
416 }
417}
418
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000419void Clang::AddARMTargetArgs(const ArgList &Args,
420 ArgStringList &CmdArgs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +0000421 const Driver &D = getToolChain().getDriver();
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000422 llvm::Triple Triple = getToolChain().getTriple();
Daniel Dunbar78485922009-09-10 23:00:09 +0000423
Daniel Dunbar4ed78982009-09-14 00:34:46 +0000424 // Select the ABI to use.
425 //
426 // FIXME: Support -meabi.
427 const char *ABIName = 0;
428 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
429 ABIName = A->getValue(Args);
430 } else {
431 // Select the default based on the platform.
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000432 llvm::StringRef env = Triple.getEnvironmentName();
Rafael Espindola23a8a062010-06-16 19:01:17 +0000433 if (env == "gnueabi")
Daniel Dunbar4ed78982009-09-14 00:34:46 +0000434 ABIName = "aapcs-linux";
Rafael Espindola23a8a062010-06-16 19:01:17 +0000435 else if (env == "eabi")
436 ABIName = "aapcs";
437 else
438 ABIName = "apcs-gnu";
Daniel Dunbar4ed78982009-09-14 00:34:46 +0000439 }
440 CmdArgs.push_back("-target-abi");
441 CmdArgs.push_back(ABIName);
442
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000443 // Set the CPU based on -march= and -mcpu=.
Daniel Dunbara7d02312009-12-18 06:30:12 +0000444 CmdArgs.push_back("-target-cpu");
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000445 CmdArgs.push_back(getARMTargetCPU(Args, Triple));
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000446
Daniel Dunbar78485922009-09-10 23:00:09 +0000447 // Select the float ABI as determined by -msoft-float, -mhard-float, and
448 // -mfloat-abi=.
449 llvm::StringRef FloatABI;
450 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
451 options::OPT_mhard_float,
452 options::OPT_mfloat_abi_EQ)) {
453 if (A->getOption().matches(options::OPT_msoft_float))
454 FloatABI = "soft";
455 else if (A->getOption().matches(options::OPT_mhard_float))
456 FloatABI = "hard";
457 else {
458 FloatABI = A->getValue(Args);
459 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
460 D.Diag(clang::diag::err_drv_invalid_mfloat_abi)
461 << A->getAsString(Args);
462 FloatABI = "soft";
463 }
464 }
465 }
466
467 // If unspecified, choose the default based on the platform.
468 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000469 const llvm::Triple &Triple = getToolChain().getTriple();
470 switch (Triple.getOS()) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000471 case llvm::Triple::Darwin: {
472 // Darwin defaults to "softfp" for v6 and v7.
473 //
474 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000475 llvm::StringRef ArchName =
476 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Daniel Dunbar78485922009-09-10 23:00:09 +0000477 if (ArchName.startswith("v6") || ArchName.startswith("v7"))
478 FloatABI = "softfp";
479 else
480 FloatABI = "soft";
481 break;
482 }
483
Rafael Espindolab1ef8ff2010-06-27 18:29:21 +0000484 case llvm::Triple::Linux: {
485 llvm::StringRef Env = getToolChain().getTriple().getEnvironmentName();
486 if (Env == "gnueabi") {
487 FloatABI = "softfp";
488 break;
489 }
490 }
491 // fall through
492
Daniel Dunbar78485922009-09-10 23:00:09 +0000493 default:
494 // Assume "soft", but warn the user we are guessing.
495 FloatABI = "soft";
496 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
497 break;
498 }
499 }
500
501 if (FloatABI == "soft") {
502 // Floating point operations and argument passing are soft.
503 //
504 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000505 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000506 CmdArgs.push_back("-mfloat-abi");
507 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000508 } else if (FloatABI == "softfp") {
509 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000510 CmdArgs.push_back("-mfloat-abi");
511 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000512 } else {
513 // Floating point operations and argument passing are hard.
514 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000515 CmdArgs.push_back("-mfloat-abi");
516 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000517 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000518
519 // Set appropriate target features for floating point mode.
520 //
521 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
522 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
523 // stripped out by the ARM target.
524
525 // Use software floating point operations?
526 if (FloatABI == "soft") {
527 CmdArgs.push_back("-target-feature");
528 CmdArgs.push_back("+soft-float");
529 }
530
531 // Use software floating point argument passing?
532 if (FloatABI != "hard") {
533 CmdArgs.push_back("-target-feature");
534 CmdArgs.push_back("+soft-float-abi");
535 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +0000536
537 // Honor -mfpu=.
538 //
539 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
540 // frontend target.
541 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
542 llvm::StringRef FPU = A->getValue(Args);
543
544 // Set the target features based on the FPU.
545 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
546 // Disable any default FPU support.
547 CmdArgs.push_back("-target-feature");
548 CmdArgs.push_back("-vfp2");
549 CmdArgs.push_back("-target-feature");
550 CmdArgs.push_back("-vfp3");
551 CmdArgs.push_back("-target-feature");
552 CmdArgs.push_back("-neon");
553 } else if (FPU == "vfp") {
554 CmdArgs.push_back("-target-feature");
555 CmdArgs.push_back("+vfp2");
556 } else if (FPU == "vfp3") {
557 CmdArgs.push_back("-target-feature");
558 CmdArgs.push_back("+vfp3");
559 } else if (FPU == "neon") {
560 CmdArgs.push_back("-target-feature");
561 CmdArgs.push_back("+neon");
562 } else
563 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
564 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000565}
566
Eric Christopher0b26a612010-03-02 02:41:08 +0000567void Clang::AddMIPSTargetArgs(const ArgList &Args,
568 ArgStringList &CmdArgs) const {
569 const Driver &D = getToolChain().getDriver();
570
571 // Select the ABI to use.
572 const char *ABIName = 0;
573 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
574 ABIName = A->getValue(Args);
575 } else {
576 ABIName = "o32";
577 }
578
579 CmdArgs.push_back("-target-abi");
580 CmdArgs.push_back(ABIName);
581
582 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
583 llvm::StringRef MArch = A->getValue(Args);
584 CmdArgs.push_back("-target-cpu");
585
586 if ((MArch == "r2000") || (MArch == "r3000"))
587 CmdArgs.push_back("mips1");
588 else if (MArch == "r6000")
589 CmdArgs.push_back("mips2");
590 else
591 CmdArgs.push_back(MArch.str().c_str());
592 }
593
594 // Select the float ABI as determined by -msoft-float, -mhard-float, and
595 llvm::StringRef FloatABI;
596 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
597 options::OPT_mhard_float)) {
598 if (A->getOption().matches(options::OPT_msoft_float))
599 FloatABI = "soft";
600 else if (A->getOption().matches(options::OPT_mhard_float))
601 FloatABI = "hard";
602 }
603
604 // If unspecified, choose the default based on the platform.
605 if (FloatABI.empty()) {
Benjamin Kramerf41ccef2010-04-08 15:44:22 +0000606 // Assume "soft", but warn the user we are guessing.
607 FloatABI = "soft";
608 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Eric Christopher0b26a612010-03-02 02:41:08 +0000609 }
610
611 if (FloatABI == "soft") {
612 // Floating point operations and argument passing are soft.
613 //
614 // FIXME: This changes CPP defines, we need -target-soft-float.
615 CmdArgs.push_back("-msoft-float");
616 } else {
617 assert(FloatABI == "hard" && "Invalid float abi!");
618 CmdArgs.push_back("-mhard-float");
619 }
620}
621
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000622void Clang::AddX86TargetArgs(const ArgList &Args,
623 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +0000624 if (!Args.hasFlag(options::OPT_mred_zone,
625 options::OPT_mno_red_zone,
626 true) ||
627 Args.hasArg(options::OPT_mkernel) ||
628 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +0000629 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +0000630
Daniel Dunbare2cf8f72009-09-10 22:59:57 +0000631 if (Args.hasFlag(options::OPT_msoft_float,
632 options::OPT_mno_soft_float,
633 false))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +0000634 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +0000635
Daniel Dunbare13ada62009-11-14 22:04:54 +0000636 const char *CPUName = 0;
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000637 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Daniel Dunbare13ada62009-11-14 22:04:54 +0000638 if (llvm::StringRef(A->getValue(Args)) == "native") {
639 // FIXME: Reject attempts to use -march=native unless the target matches
640 // the host.
641 //
642 // FIXME: We should also incorporate the detected target features for use
643 // with -native.
644 std::string CPU = llvm::sys::getHostCPUName();
645 if (!CPU.empty())
646 CPUName = Args.MakeArgString(CPU);
647 } else
648 CPUName = A->getValue(Args);
649 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000650
Daniel Dunbare13ada62009-11-14 22:04:54 +0000651 // Select the default CPU if none was given (or detection failed).
652 if (!CPUName) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000653 // FIXME: Need target hooks.
Benjamin Kramer842bf172010-01-30 15:01:47 +0000654 if (getToolChain().getOS().startswith("darwin")) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000655 if (getToolChain().getArchName() == "x86_64")
Daniel Dunbare13ada62009-11-14 22:04:54 +0000656 CPUName = "core2";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000657 else if (getToolChain().getArchName() == "i386")
Daniel Dunbare13ada62009-11-14 22:04:54 +0000658 CPUName = "yonah";
Chris Lattnerb986aba2010-04-11 19:29:39 +0000659 } else if (getToolChain().getOS().startswith("haiku")) {
660 if (getToolChain().getArchName() == "x86_64")
661 CPUName = "x86-64";
662 else if (getToolChain().getArchName() == "i386")
663 CPUName = "i586";
Daniel Dunbarea3813f2010-08-01 23:13:54 +0000664 } else if (getToolChain().getOS().startswith("openbsd")) {
665 if (getToolChain().getArchName() == "x86_64")
666 CPUName = "x86-64";
667 else if (getToolChain().getArchName() == "i386")
668 CPUName = "i486";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000669 } else {
670 if (getToolChain().getArchName() == "x86_64")
Daniel Dunbare13ada62009-11-14 22:04:54 +0000671 CPUName = "x86-64";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000672 else if (getToolChain().getArchName() == "i386")
Daniel Dunbare13ada62009-11-14 22:04:54 +0000673 CPUName = "pentium4";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000674 }
675 }
676
Daniel Dunbare13ada62009-11-14 22:04:54 +0000677 if (CPUName) {
Daniel Dunbara7d02312009-12-18 06:30:12 +0000678 CmdArgs.push_back("-target-cpu");
Daniel Dunbare13ada62009-11-14 22:04:54 +0000679 CmdArgs.push_back(CPUName);
680 }
681
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000682 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
683 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000684 llvm::StringRef Name = (*it)->getOption().getName();
685 (*it)->claim();
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000686
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000687 // Skip over "-m".
688 assert(Name.startswith("-m") && "Invalid feature name.");
689 Name = Name.substr(2);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000690
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000691 bool IsNegative = Name.startswith("no-");
692 if (IsNegative)
693 Name = Name.substr(3);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000694
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000695 CmdArgs.push_back("-target-feature");
696 CmdArgs.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000697 }
698}
699
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +0000700static bool needsExceptions(const ArgList &Args, types::ID InputType,
701 const llvm::Triple &Triple) {
Daniel Dunbar30a12b82010-09-14 23:12:31 +0000702 // Handle -fno-exceptions.
Rafael Espindola00a66572009-10-01 13:33:33 +0000703 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
704 options::OPT_fno_exceptions)) {
705 if (A->getOption().matches(options::OPT_fexceptions))
706 return true;
707 else
708 return false;
709 }
Daniel Dunbar30a12b82010-09-14 23:12:31 +0000710
711 // Otherwise, C++ inputs use exceptions.
712 if (types::isCXX(InputType))
Rafael Espindola00a66572009-10-01 13:33:33 +0000713 return true;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +0000714
Daniel Dunbar30a12b82010-09-14 23:12:31 +0000715 // As do Objective-C non-fragile ABI inputs and all Objective-C inputs on
John McCall2a981c22010-10-06 01:40:51 +0000716 // x86_64 and ARM after SnowLeopard.
Daniel Dunbar30a12b82010-09-14 23:12:31 +0000717 if (types::isObjC(InputType)) {
Rafael Espindola00a66572009-10-01 13:33:33 +0000718 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi))
719 return true;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +0000720 if (Triple.getOS() != llvm::Triple::Darwin)
Rafael Espindola00a66572009-10-01 13:33:33 +0000721 return false;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +0000722 return (Triple.getDarwinMajorNumber() >= 9 &&
John McCall2a981c22010-10-06 01:40:51 +0000723 (Triple.getArch() == llvm::Triple::x86_64 ||
724 Triple.getArch() == llvm::Triple::arm));
Rafael Espindola00a66572009-10-01 13:33:33 +0000725 }
Daniel Dunbar30a12b82010-09-14 23:12:31 +0000726
727 return false;
Rafael Espindola00a66572009-10-01 13:33:33 +0000728}
729
Daniel Dunbar1a093d22009-03-18 06:00:36 +0000730void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +0000731 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +0000732 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000733 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +0000734 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +0000735 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
736 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +0000737 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +0000738 ArgStringList CmdArgs;
739
Daniel Dunbare521a892009-03-31 20:53:55 +0000740 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
741
Daniel Dunbar6c536aa2009-12-11 23:00:49 +0000742 // Invoke ourselves in -cc1 mode.
743 //
744 // FIXME: Implement custom jobs for internal actions.
745 CmdArgs.push_back("-cc1");
746
Daniel Dunbar624c21b2009-10-30 18:12:20 +0000747 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +0000748 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +0000749 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +0000750 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000751
Daniel Dunbar624c21b2009-10-30 18:12:20 +0000752 // Select the appropriate action.
Daniel Dunbar99b55242010-07-19 19:44:22 +0000753 bool IsRewriter = false;
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000754 if (isa<AnalyzeJobAction>(JA)) {
755 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
756 CmdArgs.push_back("-analyze");
757 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +0000758 if (Output.getType() == types::TY_Dependencies)
759 CmdArgs.push_back("-Eonly");
760 else
761 CmdArgs.push_back("-E");
Daniel Dunbarc4343942010-02-03 03:07:56 +0000762 } else if (isa<AssembleJobAction>(JA)) {
763 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +0000764
765 // At -O0, we use -mrelax-all by default.
766 bool IsOpt = false;
767 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
768 IsOpt = !A->getOption().matches(options::OPT_O0);
769 if (Args.hasFlag(options::OPT_mrelax_all,
770 options::OPT_mno_relax_all,
771 !IsOpt))
772 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +0000773
Daniel Dunbar2b4de142010-10-18 22:36:15 +0000774 // When using an integrated assembler, translate -Wa, and -Xassembler
775 // options.
776 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
777 options::OPT_Xassembler),
778 ie = Args.filtered_end(); it != ie; ++it) {
779 const Arg *A = *it;
780 A->claim();
781
782 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
783 llvm::StringRef Value = A->getValue(Args, i);
784
785 if (Value == "-force_cpusubtype_ALL") {
786 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbara78e5892010-10-28 20:36:23 +0000787 } else if (Value == "-L") {
788 // We don't support -L yet, but it isn't important enough to error
789 // on. No one should really be using it for a semantic change.
790 D.Diag(clang::diag::warn_drv_unsupported_option_argument)
791 << A->getOption().getName() << Value;
Daniel Dunbar2b4de142010-10-18 22:36:15 +0000792 } else {
793 D.Diag(clang::diag::err_drv_unsupported_option_argument)
794 << A->getOption().getName() << Value;
795 }
796 }
797 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000798 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000799 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000800 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000801
802 if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000803 CmdArgs.push_back("-emit-pch");
804 else
805 CmdArgs.push_back("-emit-pth");
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000806 } else {
807 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000808
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000809 if (JA.getType() == types::TY_Nothing) {
810 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +0000811 } else if (JA.getType() == types::TY_LLVM_IR ||
812 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000813 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +0000814 } else if (JA.getType() == types::TY_LLVM_BC ||
815 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000816 CmdArgs.push_back("-emit-llvm-bc");
817 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +0000818 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +0000819 } else if (JA.getType() == types::TY_AST) {
820 CmdArgs.push_back("-emit-pch");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +0000821 } else if (JA.getType() == types::TY_RewrittenObjC) {
822 CmdArgs.push_back("-rewrite-objc");
Daniel Dunbar99b55242010-07-19 19:44:22 +0000823 IsRewriter = true;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +0000824 } else {
825 assert(JA.getType() == types::TY_PP_Asm &&
826 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000827 }
Daniel Dunbara3246a02009-03-18 08:07:30 +0000828 }
829
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000830 // The make clang go fast button.
831 CmdArgs.push_back("-disable-free");
832
John McCallbb79b5f2010-02-13 03:50:24 +0000833 // Disable the verification pass in -asserts builds.
834#ifdef NDEBUG
835 CmdArgs.push_back("-disable-llvm-verifier");
836#endif
837
Daniel Dunbar3b358a32009-04-08 05:11:16 +0000838 // Set the main file name, so that debug info works even with
839 // -save-temps.
840 CmdArgs.push_back("-main-file-name");
841 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
842
Daniel Dunbar17ddaa62009-04-08 18:03:55 +0000843 // Some flags which affect the language (via preprocessor
844 // defines). See darwin::CC1::AddCPPArgs.
845 if (Args.hasArg(options::OPT_static))
846 CmdArgs.push_back("-static-define");
847
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000848 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +0000849 // Enable region store model by default.
850 CmdArgs.push_back("-analyzer-store=region");
851
Ted Kremenek7bea9a12009-12-07 22:26:14 +0000852 // Treat blocks as analysis entry points.
853 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
854
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000855 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +0000856 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Ted Kremenekd519b832010-02-05 01:52:40 +0000857 CmdArgs.push_back("-analyzer-check-dead-stores");
Ted Kremenekd8a23f92010-04-29 22:50:22 +0000858 // Do not enable the security-syntatic check since it
859 // it needs to be refined (known issues).
860 // CmdArgs.push_back("-analyzer-check-security-syntactic");
Ted Kremenek2f2692f2010-02-05 02:06:54 +0000861 CmdArgs.push_back("-analyzer-check-objc-mem");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +0000862 CmdArgs.push_back("-analyzer-eagerly-assume");
Ted Kremenek61b506a2010-02-05 01:57:44 +0000863 CmdArgs.push_back("-analyzer-check-objc-methodsigs");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +0000864 // Do not enable the missing -dealloc check.
Ted Kremenekb6e400c2010-02-05 01:59:21 +0000865 // '-analyzer-check-objc-missing-dealloc',
Ted Kremenek2d8ef712010-02-05 01:55:01 +0000866 CmdArgs.push_back("-analyzer-check-objc-unused-ivars");
Ted Kremenek04768992010-08-10 18:03:13 +0000867 CmdArgs.push_back("-analyzer-check-idempotent-operations");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +0000868 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000869
Daniel Dunbar58f345ce2009-05-22 00:38:15 +0000870 // Set the output format. The default is plist, for (lame) historical
871 // reasons.
872 CmdArgs.push_back("-analyzer-output");
873 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
874 CmdArgs.push_back(A->getValue(Args));
875 else
876 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000877
Ted Kremenekfe449a22010-03-22 22:32:05 +0000878 // Disable the presentation of standard compiler warnings when
879 // using --analyze. We only want to show static analyzer diagnostics
880 // or frontend errors.
881 CmdArgs.push_back("-w");
882
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000883 // Add -Xanalyzer arguments when running as analyzer.
884 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +0000885 }
886
Daniel Dunbar4eadb602009-09-10 01:21:12 +0000887 CheckCodeGenerationOptions(D, Args);
888
Daniel Dunbar44e71222009-04-29 18:32:25 +0000889 // Perform argument translation for LLVM backend. This
890 // takes some care in reconciling with llvm-gcc. The
891 // issue is that llvm-gcc translates these options based on
892 // the values in cc1, whereas we are processing based on
893 // the driver arguments.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000894
Daniel Dunbar44e71222009-04-29 18:32:25 +0000895 // This comes from the default translation the driver + cc1
896 // would do to enable flag_pic.
897 //
898 // FIXME: Centralize this code.
899 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
900 Args.hasArg(options::OPT_fpic) ||
901 Args.hasArg(options::OPT_fPIE) ||
902 Args.hasArg(options::OPT_fpie));
903 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
904 Args.hasArg(options::OPT_static));
905 const char *Model = getToolChain().GetForcedPicModel();
906 if (!Model) {
907 if (Args.hasArg(options::OPT_mdynamic_no_pic))
908 Model = "dynamic-no-pic";
909 else if (PICDisabled)
910 Model = "static";
911 else if (PICEnabled)
912 Model = "pic";
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000913 else
Daniel Dunbar44e71222009-04-29 18:32:25 +0000914 Model = getToolChain().GetDefaultRelocationModel();
Daniel Dunbara2aedc62009-03-18 10:01:51 +0000915 }
Daniel Dunbara1b02a22009-11-29 07:18:39 +0000916 if (llvm::StringRef(Model) != "pic") {
917 CmdArgs.push_back("-mrelocation-model");
918 CmdArgs.push_back(Model);
919 }
Daniel Dunbar44e71222009-04-29 18:32:25 +0000920
921 // Infer the __PIC__ value.
922 //
923 // FIXME: This isn't quite right on Darwin, which always sets
924 // __PIC__=2.
925 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +0000926 CmdArgs.push_back("-pic-level");
927 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
Daniel Dunbar44e71222009-04-29 18:32:25 +0000928 }
Tanya Lattnerf9d41df2009-11-04 01:18:09 +0000929 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
930 options::OPT_fno_merge_all_constants))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +0000931 CmdArgs.push_back("-no-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +0000932
Daniel Dunbara1b02a22009-11-29 07:18:39 +0000933 // LLVM Code Generator Options.
934
935 // FIXME: Set --enable-unsafe-fp-math.
936 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
937 options::OPT_fomit_frame_pointer))
938 CmdArgs.push_back("-mdisable-fp-elim");
939 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
940 options::OPT_fno_zero_initialized_in_bss))
941 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Dan Gohman10169b92010-10-14 22:36:56 +0000942 if (Args.hasFlag(options::OPT_fno_strict_aliasing,
943 options::OPT_fstrict_aliasing,
944 false))
945 CmdArgs.push_back("-relaxed-aliasing");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +0000946
947 // Decide whether to use verbose asm. Verbose assembly is the default on
948 // toolchains which have the integrated assembler on by default.
949 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
950 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000951 IsVerboseAsmDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +0000952 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +0000953 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +0000954
Daniel Dunbara1b02a22009-11-29 07:18:39 +0000955 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
956 CmdArgs.push_back("-mdebug-pass");
957 CmdArgs.push_back("Structure");
958 }
959 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
960 CmdArgs.push_back("-mdebug-pass");
961 CmdArgs.push_back("Arguments");
962 }
963
John McCall8517abc2010-02-19 02:45:38 +0000964 // Enable -mconstructor-aliases except on darwin, where we have to
965 // work around a linker bug; see <rdar://problem/7651567>.
966 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin)
967 CmdArgs.push_back("-mconstructor-aliases");
968
Daniel Dunbar306945d2009-09-16 06:17:29 +0000969 // This is a coarse approximation of what llvm-gcc actually does, both
970 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
971 // complicated ways.
972 bool AsynchronousUnwindTables =
973 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
974 options::OPT_fno_asynchronous_unwind_tables,
975 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbare46b52a2010-03-20 04:52:14 +0000976 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +0000977 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
978 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +0000979 CmdArgs.push_back("-munwind-tables");
980
981 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
982 CmdArgs.push_back("-mlimit-float-precision");
983 CmdArgs.push_back(A->getValue(Args));
984 }
Daniel Dunbar44e71222009-04-29 18:32:25 +0000985
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000986 // FIXME: Handle -mtune=.
987 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +0000988
Benjamin Kramercf4371a2009-08-05 14:30:52 +0000989 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +0000990 CmdArgs.push_back("-mcode-model");
Benjamin Kramercf4371a2009-08-05 14:30:52 +0000991 CmdArgs.push_back(A->getValue(Args));
992 }
993
Daniel Dunbar3b3191f2009-09-09 22:33:08 +0000994 // Add target specific cpu and features flags.
995 switch(getToolChain().getTriple().getArch()) {
996 default:
997 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000998
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000999 case llvm::Triple::arm:
1000 case llvm::Triple::thumb:
1001 AddARMTargetArgs(Args, CmdArgs);
1002 break;
1003
Eric Christopher0b26a612010-03-02 02:41:08 +00001004 case llvm::Triple::mips:
1005 case llvm::Triple::mipsel:
1006 AddMIPSTargetArgs(Args, CmdArgs);
1007 break;
1008
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001009 case llvm::Triple::x86:
1010 case llvm::Triple::x86_64:
1011 AddX86TargetArgs(Args, CmdArgs);
1012 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00001013 }
1014
Daniel Dunbar976a2f52010-08-11 23:07:47 +00001015 // Pass the linker version in use.
1016 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1017 CmdArgs.push_back("-target-linker-version");
1018 CmdArgs.push_back(A->getValue(Args));
1019 }
1020
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00001021 // -mno-omit-leaf-frame-pointer is default.
1022 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
1023 options::OPT_mno_omit_leaf_frame_pointer, false))
1024 CmdArgs.push_back("-momit-leaf-frame-pointer");
1025
Dan Gohmand1e76b92010-01-08 02:20:44 +00001026 // -fno-math-errno is default.
1027 if (Args.hasFlag(options::OPT_fmath_errno,
Daniel Dunbar44e71222009-04-29 18:32:25 +00001028 options::OPT_fno_math_errno,
Dan Gohmand1e76b92010-01-08 02:20:44 +00001029 false))
1030 CmdArgs.push_back("-fmath-errno");
Daniel Dunbar44e71222009-04-29 18:32:25 +00001031
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00001032 // Explicitly error on some things we know we don't support and can't just
1033 // ignore.
1034 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00001035 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1036 Arg *Unsupported;
1037 if ((Unsupported = Args.getLastArg(options::OPT_MG)) ||
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00001038 (Unsupported = Args.getLastArg(options::OPT_iframework)))
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00001039 D.Diag(clang::diag::err_drv_clang_unsupported)
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00001040 << Unsupported->getOption().getName();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00001041
1042 if (types::isCXX(InputType) &&
1043 getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1044 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1045 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)))
1046 D.Diag(clang::diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1047 << Unsupported->getOption().getName();
1048 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00001049 }
1050
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001051 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00001052 Args.AddLastArg(CmdArgs, options::OPT_H);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001053 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00001054 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001055
1056 // Special case debug options to only pass -g to clang. This is
1057 // wrong.
Rafael Espindola08a692a2010-03-07 04:46:18 +00001058 Args.ClaimAllArgs(options::OPT_g_Group);
Daniel Dunbar4083d042010-05-12 18:19:55 +00001059 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
1060 if (!A->getOption().matches(options::OPT_g0))
1061 CmdArgs.push_back("-g");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001062
Rafael Espindola66bfb2752010-05-06 21:06:04 +00001063 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1064 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1065
Chris Lattner3c77a352010-06-22 00:03:40 +00001066 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
1067
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001068 Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
Douglas Gregor64b046f2010-03-24 20:13:48 +00001069 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
Rafael Espindolab3549d72009-10-26 13:36:57 +00001070 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001071
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00001072 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00001073 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00001074 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00001075
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001076 // Add preprocessing options like -I, -D, etc. if we are using the
1077 // preprocessor.
1078 //
1079 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001080 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Douglas Gregor111af7d2009-04-18 00:34:01 +00001081 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001082
Daniel Dunbar58f78332009-09-17 06:53:36 +00001083 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar13864952009-03-24 20:17:30 +00001084 // others.
1085 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001086 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar13864952009-03-24 20:17:30 +00001087 CmdArgs.push_back("-O3");
Daniel Dunbar9296f632010-05-27 06:51:08 +00001088 else if (A->getOption().matches(options::OPT_O) &&
1089 A->getValue(Args)[0] == '\0')
Daniel Dunbar58f78332009-09-17 06:53:36 +00001090 CmdArgs.push_back("-O2");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001091 else
Daniel Dunbar7ef5ed62009-03-18 23:39:35 +00001092 A->render(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001093 }
1094
Daniel Dunbar945577c2009-10-29 02:24:45 +00001095 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
1096 Args.AddLastArg(CmdArgs, options::OPT_pedantic);
1097 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001098 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00001099
1100 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
1101 // (-ansi is equivalent to -std=c89).
1102 //
1103 // If a std is supplied, only add -trigraphs if it follows the
1104 // option.
1105 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1106 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00001107 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00001108 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00001109 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00001110 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00001111 else
1112 Std->render(Args, CmdArgs);
1113
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00001114 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
1115 options::OPT_trigraphs))
1116 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00001117 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00001118 } else {
1119 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00001120 //
1121 // FIXME: Clang doesn't correctly handle -std= when the input language
1122 // doesn't match. For the time being just ignore this for C++ inputs;
1123 // eventually we want to do all the standard defaulting here instead of
1124 // splitting it between the driver and clang -cc1.
1125 if (!types::isCXX(InputType))
1126 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1127 "-std=", /*Joined=*/true);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00001128 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00001129 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001130
Chandler Carruthe0391482010-05-22 02:21:53 +00001131 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
1132 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
1133 if (Asm->getOption().matches(options::OPT_fasm))
1134 CmdArgs.push_back("-fgnu-keywords");
1135 else
1136 CmdArgs.push_back("-fno-gnu-keywords");
1137 }
1138
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001139 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
1140 CmdArgs.push_back("-ftemplate-depth");
1141 CmdArgs.push_back(A->getValue(Args));
1142 }
1143
Daniel Dunbarfffd1812009-11-19 04:00:53 +00001144 if (Args.hasArg(options::OPT__relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001145 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00001146
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00001147 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
1148 CmdArgs.push_back("-fconstant-string-class");
1149 CmdArgs.push_back(A->getValue(Args));
1150 }
David Chisnall5778fce2009-08-31 16:41:57 +00001151
Chris Lattnere23003d2010-01-09 21:54:33 +00001152 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
1153 CmdArgs.push_back("-ftabstop");
1154 CmdArgs.push_back(A->getValue(Args));
1155 }
1156
Chris Lattnerb35583d2010-04-07 20:49:23 +00001157 CmdArgs.push_back("-ferror-limit");
1158 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
1159 CmdArgs.push_back(A->getValue(Args));
1160 else
1161 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00001162
Chandler Carrutha77a7272010-05-06 04:55:18 +00001163 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
1164 CmdArgs.push_back("-fmacro-backtrace-limit");
Douglas Gregorcd121fb2010-05-04 17:13:42 +00001165 CmdArgs.push_back(A->getValue(Args));
Chandler Carrutha77a7272010-05-06 04:55:18 +00001166 }
1167
1168 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
1169 CmdArgs.push_back("-ftemplate-backtrace-limit");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00001170 CmdArgs.push_back(A->getValue(Args));
Chandler Carrutha77a7272010-05-06 04:55:18 +00001171 }
1172
Daniel Dunbar2c978472009-11-04 06:24:47 +00001173 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00001174 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00001175 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Daniel Dunbar84bb7932009-11-30 08:40:54 +00001176 CmdArgs.push_back(A->getValue(Args));
Daniel Dunbar2c978472009-11-04 06:24:47 +00001177 } else {
1178 // If -fmessage-length=N was not specified, determine whether this is a
1179 // terminal and, if so, implicitly define -fmessage-length appropriately.
1180 unsigned N = llvm::sys::Process::StandardErrColumns();
Daniel Dunbar2c978472009-11-04 06:24:47 +00001181 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N)));
1182 }
1183
Daniel Dunbare357d562009-12-03 18:42:11 +00001184 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
1185 CmdArgs.push_back("-fvisibility");
1186 CmdArgs.push_back(A->getValue(Args));
1187 }
1188
Douglas Gregor08329632010-06-15 17:05:35 +00001189 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001190
Daniel Dunbare46b52a2010-03-20 04:52:14 +00001191 // -fhosted is default.
1192 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
1193 options::OPT_fhosted,
1194 false))
1195 CmdArgs.push_back("-ffreestanding");
1196
Daniel Dunbare357d562009-12-03 18:42:11 +00001197 // Forward -f (flag) options which we can pass directly.
Mike Stumpd9546382009-12-12 01:27:46 +00001198 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00001199 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00001200 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patel91bbb552010-09-30 19:05:55 +00001201 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Daniel Dunbar35621a92010-03-16 16:57:46 +00001202
1203 // -flax-vector-conversions is default.
1204 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
1205 options::OPT_fno_lax_vector_conversions))
1206 CmdArgs.push_back("-fno-lax-vector-conversions");
1207
Daniel Dunbar16334e12010-04-10 16:20:23 +00001208 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
1209 // takes precedence.
1210 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
1211 if (!GCArg)
1212 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
1213 if (GCArg) {
1214 if (getToolChain().SupportsObjCGC()) {
1215 GCArg->render(Args, CmdArgs);
1216 } else {
1217 // FIXME: We should move this to a hard error.
1218 D.Diag(clang::diag::warn_drv_objc_gc_unsupported)
1219 << GCArg->getAsString(Args);
1220 }
1221 }
1222
Daniel Dunbar3a148f22009-04-07 21:51:40 +00001223 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column);
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00001224 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00001225 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00001226 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00001227 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
1228 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00001229
1230 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
1231 CmdArgs.push_back("-ftrapv-handler");
1232 CmdArgs.push_back(A->getValue(Args));
1233 }
1234
Chris Lattner51924e512010-06-26 21:25:03 +00001235 Args.AddLastArg(CmdArgs, options::OPT_fwrapv);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00001236 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf387dbd2010-08-07 23:08:14 +00001237 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001238
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00001239 Args.AddLastArg(CmdArgs, options::OPT_pthread);
1240
Daniel Dunbar4930e332009-11-17 08:07:36 +00001241 // -stack-protector=0 is default.
1242 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00001243 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
1244 options::OPT_fstack_protector_all,
1245 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00001246 if (A->getOption().matches(options::OPT_fstack_protector))
1247 StackProtectorLevel = 1;
1248 else if (A->getOption().matches(options::OPT_fstack_protector_all))
1249 StackProtectorLevel = 2;
1250 } else
1251 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel();
1252 if (StackProtectorLevel) {
1253 CmdArgs.push_back("-stack-protector");
1254 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel)));
Bill Wendlingd63bbad2009-06-28 07:36:13 +00001255 }
1256
Daniel Dunbard18049a2009-04-07 21:16:11 +00001257 // Forward -f options with positive and negative forms; we translate
1258 // these by hand.
1259
Daniel Dunbar4930e332009-11-17 08:07:36 +00001260 // -fbuiltin is default.
Daniel Dunbard18049a2009-04-07 21:16:11 +00001261 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00001262 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00001263
Nuno Lopes13c88c72009-12-16 16:59:22 +00001264 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1265 options::OPT_fno_assume_sane_operator_new))
1266 CmdArgs.push_back("-fno-assume-sane-operator-new");
1267
Daniel Dunbar4930e332009-11-17 08:07:36 +00001268 // -fblocks=0 is default.
1269 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnall950a9512009-11-17 19:33:30 +00001270 getToolChain().IsBlocksDefault())) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00001271 CmdArgs.push_back("-fblocks");
David Chisnall950a9512009-11-17 19:33:30 +00001272 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00001273
John McCalldfea9982010-04-09 19:12:06 +00001274 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00001275 if (Args.hasFlag(options::OPT_fno_access_control,
1276 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00001277 false))
John McCall3155f572010-04-09 19:03:51 +00001278 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00001279
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00001280 // -fexceptions=0 is default.
Daniel Dunbar859dba62010-09-09 21:17:44 +00001281 if (!KernelOrKext &&
1282 needsExceptions(Args, InputType, getToolChain().getTriple()))
Rafael Espindola00a66572009-10-01 13:33:33 +00001283 CmdArgs.push_back("-fexceptions");
Mike Stump183c3d22009-07-31 23:15:31 +00001284
Daniel Dunbar3241d402010-02-10 18:49:11 +00001285 if (getToolChain().UseSjLjExceptions())
1286 CmdArgs.push_back("-fsjlj-exceptions");
1287
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00001288 // -frtti is default.
Daniel Dunbare46b52a2010-03-20 04:52:14 +00001289 if (KernelOrKext ||
1290 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
Daniel Dunbar484afa22009-11-19 04:55:23 +00001291 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00001292
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00001293 // -fshort-enums=0 is default.
1294 // FIXME: Are there targers where -fshort-enums is on by default ?
1295 if (Args.hasFlag(options::OPT_fshort_enums,
1296 options::OPT_fno_short_enums, false))
1297 CmdArgs.push_back("-fshort-enums");
1298
Daniel Dunbard609b7b2009-11-17 06:37:03 +00001299 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00001300 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00001301 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00001302 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00001303
Anders Carlssonfcd764a2010-02-06 23:23:06 +00001304 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001305 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00001306 options::OPT_fno_threadsafe_statics))
1307 CmdArgs.push_back("-fno-threadsafe-statics");
1308
Daniel Dunbarfe06df42010-03-20 04:15:41 +00001309 // -fuse-cxa-atexit is default.
Anton Korobeynikov82b33332010-09-11 11:17:06 +00001310 if (KernelOrKext ||
1311 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
NAKAMURA Takumi6bdc8a22010-10-10 01:53:03 +00001312 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
Anton Korobeynikov82b33332010-09-11 11:17:06 +00001313 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
1314 getToolChain().getTriple().getOS() != llvm::Triple::MinGW64))
Daniel Dunbarfe06df42010-03-20 04:15:41 +00001315 CmdArgs.push_back("-fno-use-cxa-atexit");
1316
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00001317 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00001318 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00001319 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1320 CmdArgs.push_back("-fms-extensions");
1321
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001322 // -fmsc-version=1300 is default.
1323 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1324 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
1325 Args.hasArg(options::OPT_fmsc_version)) {
1326 llvm::StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
1327 if (msc_ver.empty())
1328 CmdArgs.push_back("-fmsc-version=1300");
1329 else
1330 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
1331 }
1332
1333
Dawn Perchik68bb1b42010-09-02 23:59:25 +00001334 // -fborland-extensions=0 is default.
1335 if (Args.hasFlag(options::OPT_fborland_extensions,
1336 options::OPT_fno_borland_extensions, false))
1337 CmdArgs.push_back("-fborland-extensions");
1338
Chandler Carruthe03aa552010-04-17 20:17:31 +00001339 // -fgnu-keywords default varies depending on language; only pass if
1340 // specified.
1341 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00001342 options::OPT_fno_gnu_keywords))
1343 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00001344
Daniel Dunbar99b55242010-07-19 19:44:22 +00001345 // -fnext-runtime defaults to on Darwin and when rewriting Objective-C, and is
1346 // -the -cc1 default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001347 bool NeXTRuntimeIsDefault =
Daniel Dunbar99b55242010-07-19 19:44:22 +00001348 IsRewriter || getToolChain().getTriple().getOS() == llvm::Triple::Darwin;
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00001349 if (!Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
Daniel Dunbar99b55242010-07-19 19:44:22 +00001350 NeXTRuntimeIsDefault))
Daniel Dunbar4656c532009-11-17 07:07:28 +00001351 CmdArgs.push_back("-fgnu-runtime");
1352
Daniel Dunbar4930e332009-11-17 08:07:36 +00001353 // -fobjc-nonfragile-abi=0 is default.
1354 if (types::isObjC(InputType)) {
Daniel Dunbarc1dd0e92010-09-20 18:19:55 +00001355 // Compute the Objective-C ABI "version" to use. Version numbers are
1356 // slightly confusing for historical reasons:
1357 // 1 - Traditional "fragile" ABI
1358 // 2 - Non-fragile ABI, version 1
1359 // 3 - Non-fragile ABI, version 2
Daniel Dunbar12c82082010-04-28 23:25:24 +00001360 unsigned Version = 1;
Daniel Dunbarc1dd0e92010-09-20 18:19:55 +00001361 // If -fobjc-abi-version= is present, use that to set the version.
Daniel Dunbar12c82082010-04-28 23:25:24 +00001362 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
1363 if (llvm::StringRef(A->getValue(Args)) == "1")
1364 Version = 1;
1365 else if (llvm::StringRef(A->getValue(Args)) == "2")
1366 Version = 2;
Fariborz Jahanianf51a3872010-09-15 16:00:51 +00001367 else if (llvm::StringRef(A->getValue(Args)) == "3")
1368 Version = 3;
Daniel Dunbar12c82082010-04-28 23:25:24 +00001369 else
1370 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbarc1dd0e92010-09-20 18:19:55 +00001371 } else {
1372 // Otherwise, determine if we are using the non-fragile ABI.
1373 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
1374 options::OPT_fno_objc_nonfragile_abi,
1375 getToolChain().IsObjCNonFragileABIDefault())) {
1376 // Determine the non-fragile ABI version to use.
1377 unsigned NonFragileABIVersion = 2;
1378
1379 if (Arg *A = Args.getLastArg(
1380 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
1381 if (llvm::StringRef(A->getValue(Args)) == "1")
1382 NonFragileABIVersion = 1;
1383 else if (llvm::StringRef(A->getValue(Args)) == "2")
1384 NonFragileABIVersion = 2;
1385 else
1386 D.Diag(clang::diag::err_drv_clang_unsupported)
1387 << A->getAsString(Args);
1388 }
1389
1390 Version = 1 + NonFragileABIVersion;
1391 } else {
1392 Version = 1;
1393 }
Daniel Dunbar12c82082010-04-28 23:25:24 +00001394 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001395
Fariborz Jahanianf51a3872010-09-15 16:00:51 +00001396 if (Version == 2 || Version == 3) {
1397 if (Version == 2)
1398 CmdArgs.push_back("-fobjc-nonfragile-abi");
1399 else
1400 CmdArgs.push_back("-fobjc-nonfragile-abi2");
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +00001401
1402 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
1403 // legacy is the default.
1404 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
1405 options::OPT_fno_objc_legacy_dispatch,
1406 getToolChain().IsObjCLegacyDispatchDefault())) {
1407 if (getToolChain().UseObjCMixedDispatch())
1408 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
1409 else
1410 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
1411 }
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00001412 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00001413 }
1414
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00001415 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1416 options::OPT_fno_assume_sane_operator_new))
1417 CmdArgs.push_back("-fno-assume-sane-operator-new");
1418
Daniel Dunbar34d7a992010-04-27 15:34:57 +00001419 // -fconstant-cfstrings is default, and may be subject to argument translation
1420 // on Darwin.
1421 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
1422 options::OPT_fno_constant_cfstrings) ||
1423 !Args.hasFlag(options::OPT_mconstant_cfstrings,
1424 options::OPT_mno_constant_cfstrings))
1425 CmdArgs.push_back("-fno-constant-cfstrings");
1426
John Thompsoned4e2952009-11-05 20:14:16 +00001427 // -fshort-wchar default varies depending on platform; only
1428 // pass if specified.
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00001429 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
1430 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00001431
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +00001432 // -fno-pascal-strings is default, only pass non-default. If the tool chain
1433 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbard4510f22009-04-07 23:51:44 +00001434 //
1435 // FIXME: This is gross; that translation should be pulled from the
1436 // tool chain.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001437 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00001438 options::OPT_fno_pascal_strings,
1439 false) ||
1440 Args.hasFlag(options::OPT_mpascal_strings,
1441 options::OPT_mno_pascal_strings,
1442 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00001443 CmdArgs.push_back("-fpascal-strings");
1444
1445 // -fcommon is default, only pass non-default.
1446 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
1447 CmdArgs.push_back("-fno-common");
1448
Daniel Dunbar2edd9232009-04-15 02:37:43 +00001449 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00001450 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00001451 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00001452 options::OPT_funsigned_bitfields))
1453 D.Diag(clang::diag::warn_drv_clang_unsupported)
1454 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
1455
Daniel Dunbar6358d682010-10-15 22:30:42 +00001456 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
1457 if (!Args.hasFlag(options::OPT_ffor_scope,
1458 options::OPT_fno_for_scope))
1459 D.Diag(clang::diag::err_drv_clang_unsupported)
1460 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
1461
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00001462 // -fcaret-diagnostics is default.
1463 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
1464 options::OPT_fno_caret_diagnostics, true))
1465 CmdArgs.push_back("-fno-caret-diagnostics");
1466
Daniel Dunbar8281bde2009-04-19 21:09:34 +00001467 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00001468 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00001469 options::OPT_fno_diagnostics_fixit_info))
1470 CmdArgs.push_back("-fno-diagnostics-fixit-info");
1471
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00001472 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00001473 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00001474 options::OPT_fno_diagnostics_show_option))
1475 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00001476
Chris Lattnerbf6fac82010-05-04 21:55:25 +00001477 if (const Arg *A =
1478 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
1479 CmdArgs.push_back("-fdiagnostics-show-category");
1480 CmdArgs.push_back(A->getValue(Args));
1481 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001482
Daniel Dunbar5ec95022009-11-04 06:24:57 +00001483 // Color diagnostics are the default, unless the terminal doesn't support
1484 // them.
1485 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidis4f920162010-09-23 12:56:06 +00001486 options::OPT_fno_color_diagnostics,
1487 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00001488 CmdArgs.push_back("-fcolor-diagnostics");
1489
Daniel Dunbardb097022009-06-08 21:13:54 +00001490 if (!Args.hasFlag(options::OPT_fshow_source_location,
1491 options::OPT_fno_show_source_location))
1492 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00001493
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00001494 if (!Args.hasFlag(options::OPT_fspell_checking,
1495 options::OPT_fno_spell_checking))
1496 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001497
Daniel Dunbar473f8a62010-10-18 22:49:46 +00001498
1499 // -fasm-blocks is disallowed except on X86, where we just ignore it.
1500 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
1501 false)) {
1502 if (getToolChain().getTriple().getArch() != llvm::Triple::x86 &&
1503 getToolChain().getTriple().getArch() != llvm::Triple::x86_64)
1504 D.Diag(clang::diag::err_drv_clang_unsupported_per_platform)
1505 << "-fasm-blocks";
1506 }
1507
1508 // -fasm-blocks is disallowed except on X86, where we just ignore it.
1509
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00001510 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
1511 A->render(Args, CmdArgs);
1512
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00001513 // -fdollars-in-identifiers default varies depending on platform and
1514 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00001515 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00001516 options::OPT_fno_dollars_in_identifiers)) {
1517 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00001518 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00001519 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00001520 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00001521 }
1522
Daniel Dunbaradeeb052009-05-22 19:02:20 +00001523 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
1524 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00001525 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00001526 options::OPT_fno_unit_at_a_time)) {
1527 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Edward O'Callaghanfc460552009-10-13 16:41:34 +00001528 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00001529 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00001530
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00001531 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00001532 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00001533 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00001534#if 0
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00001535 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1536 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
1537 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
1538 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
1539 CmdArgs.push_back("-fno-builtin-strcat");
1540 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
1541 CmdArgs.push_back("-fno-builtin-strcpy");
1542 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00001543#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00001544
Mike Stump11289f42009-09-09 15:08:12 +00001545 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00001546 options::OPT_traditional_cpp))
1547 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
1548
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001549 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00001550 Args.AddLastArg(CmdArgs, options::OPT_dD);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001551
Daniel Dunbar76fa8402010-04-15 06:09:03 +00001552 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
1553 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001554 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00001555 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
1556 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00001557 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00001558
Daniel Dunbar76fa8402010-04-15 06:09:03 +00001559 // We translate this by hand to the -cc1 argument, since nightly test uses
1560 // it and developers have been trained to spell it with -mllvm.
Daniel Dunbara442fd52010-06-11 22:00:13 +00001561 if (llvm::StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00001562 CmdArgs.push_back("-disable-llvm-optzns");
1563 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00001564 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00001565 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001566
Daniel Dunbard67a3222009-03-30 06:36:42 +00001567 if (Output.getType() == types::TY_Dependencies) {
1568 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001569 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001570 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001571 CmdArgs.push_back(Output.getFilename());
1572 } else {
1573 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00001574 }
1575
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001576 for (InputInfoList::const_iterator
1577 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1578 const InputInfo &II = *it;
1579 CmdArgs.push_back("-x");
1580 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbarb440f562010-08-02 02:38:21 +00001581 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001582 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001583 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001584 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001585 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001586
Chris Lattnere9d7d782009-11-03 19:50:27 +00001587 Args.AddAllArgs(CmdArgs, options::OPT_undef);
1588
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00001589 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00001590
1591 // Optionally embed the -cc1 level arguments into the debug info, for build
1592 // analysis.
1593 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00001594 ArgStringList OriginalArgs;
1595 for (ArgList::const_iterator it = Args.begin(),
1596 ie = Args.end(); it != ie; ++it)
1597 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001598
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00001599 llvm::SmallString<256> Flags;
1600 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00001601 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00001602 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00001603 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00001604 }
1605 CmdArgs.push_back("-dwarf-debug-flags");
1606 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
1607 }
1608
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00001609 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar17731772009-03-23 19:03:36 +00001610
Daniel Dunbar513d5002009-04-07 19:18:24 +00001611 // Explicitly warn that these options are unsupported, even though
1612 // we are allowing compilation to continue.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001613 for (arg_iterator it = Args.filtered_begin(options::OPT_pg),
1614 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00001615 (*it)->claim();
1616 D.Diag(clang::diag::warn_drv_clang_unsupported) << (*it)->getAsString(Args);
Daniel Dunbar513d5002009-04-07 19:18:24 +00001617 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001618
Daniel Dunbarc2a71892009-04-03 20:51:31 +00001619 // Claim some arguments which clang supports automatically.
1620
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00001621 // -fpch-preprocess is used with gcc to add a special marker in the output to
1622 // include the PCH file. Clang's PTH solution is completely transparent, so we
1623 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00001624 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001625
Daniel Dunbar17731772009-03-23 19:03:36 +00001626 // Claim some arguments which clang doesn't support, but we don't
1627 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001628 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
1629 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001630}
1631
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001632void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001633 const InputInfo &Output,
1634 const InputInfoList &Inputs,
1635 const ArgList &Args,
1636 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001637 ArgStringList CmdArgs;
1638
1639 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
1640 const InputInfo &Input = Inputs[0];
1641
1642 // Invoke ourselves in -cc1as mode.
1643 //
1644 // FIXME: Implement custom jobs for internal actions.
1645 CmdArgs.push_back("-cc1as");
1646
1647 // Add the "effective" target triple.
1648 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00001649 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001650 CmdArgs.push_back(Args.MakeArgString(TripleStr));
1651
1652 // Set the output mode, we currently only expect to be used as a real
1653 // assembler.
1654 CmdArgs.push_back("-filetype");
1655 CmdArgs.push_back("obj");
1656
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001657 // At -O0, we use -mrelax-all by default.
1658 bool IsOpt = false;
1659 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1660 IsOpt = !A->getOption().matches(options::OPT_O0);
1661 if (Args.hasFlag(options::OPT_mrelax_all,
1662 options::OPT_mno_relax_all,
1663 !IsOpt))
Daniel Dunbar99ca8b72010-05-28 16:43:21 +00001664 CmdArgs.push_back("-relax-all");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001665
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001666 // FIXME: Add -force_cpusubtype_ALL support, once we have it.
1667
1668 // FIXME: Add -g support, once we have it.
1669
1670 // FIXME: Add -static support, once we have it.
1671
1672 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
1673 options::OPT_Xassembler);
1674
1675 assert(Output.isFilename() && "Unexpected lipo output.");
1676 CmdArgs.push_back("-o");
1677 CmdArgs.push_back(Output.getFilename());
1678
Daniel Dunbarb440f562010-08-02 02:38:21 +00001679 assert(Input.isFilename() && "Invalid input.");
1680 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001681
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00001682 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00001683 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00001684}
1685
Daniel Dunbara3246a02009-03-18 08:07:30 +00001686void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00001687 const InputInfo &Output,
1688 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001689 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00001690 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00001691 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00001692 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001693
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001694 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001695 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001696 Arg *A = *it;
Daniel Dunbar2da02722009-03-19 07:55:12 +00001697 if (A->getOption().hasForwardToGCC()) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00001698 // Don't forward any -g arguments to assembly steps.
1699 if (isa<AssembleJobAction>(JA) &&
1700 A->getOption().matches(options::OPT_g_Group))
1701 continue;
1702
Daniel Dunbar2da02722009-03-19 07:55:12 +00001703 // It is unfortunate that we have to claim here, as this means
1704 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00001705 // platforms using a generic gcc, even if we are just using gcc
1706 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00001707 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001708 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00001709 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001710 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001711
Daniel Dunbar4e295052010-01-25 22:35:08 +00001712 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00001713
1714 // If using a driver driver, force the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00001715 const std::string &Arch = getToolChain().getArchName();
Daniel Dunbarf4894fe2009-12-23 00:46:38 +00001716 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001717 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00001718
1719 // FIXME: Remove these special cases.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00001720 if (Arch == "powerpc")
1721 CmdArgs.push_back("ppc");
1722 else if (Arch == "powerpc64")
1723 CmdArgs.push_back("ppc64");
1724 else
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00001725 CmdArgs.push_back(Args.MakeArgString(Arch));
Daniel Dunbara3246a02009-03-18 08:07:30 +00001726 }
1727
Daniel Dunbar5716d872009-05-02 21:41:52 +00001728 // Try to force gcc to match the tool chain we want, if we recognize
1729 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00001730 //
1731 // FIXME: The triple class should directly provide the information we want
1732 // here.
1733 if (Arch == "i386" || Arch == "powerpc")
Daniel Dunbar5716d872009-05-02 21:41:52 +00001734 CmdArgs.push_back("-m32");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00001735 else if (Arch == "x86_64" || Arch == "powerpc64")
Daniel Dunbar5716d872009-05-02 21:41:52 +00001736 CmdArgs.push_back("-m64");
1737
Daniel Dunbarb440f562010-08-02 02:38:21 +00001738 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001739 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001740 CmdArgs.push_back(Output.getFilename());
1741 } else {
1742 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00001743 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001744 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001745
1746
1747 // Only pass -x if gcc will understand it; otherwise hope gcc
1748 // understands the suffix correctly. The main use case this would go
1749 // wrong in is for linker inputs if they happened to have an odd
1750 // suffix; really the only way to get this to happen is a command
1751 // like '-x foobar a.c' which will treat a.c like a linker input.
1752 //
1753 // FIXME: For the linker case specifically, can we safely convert
1754 // inputs into '-Wl,' options?
1755 for (InputInfoList::const_iterator
1756 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1757 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00001758
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001759 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00001760 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
1761 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Daniel Dunbare3e263f2009-05-02 20:14:53 +00001762 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00001763 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001764 else if (II.getType() == types::TY_AST)
1765 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00001766 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00001767
Daniel Dunbara3246a02009-03-18 08:07:30 +00001768 if (types::canTypeBeUserSpecified(II.getType())) {
1769 CmdArgs.push_back("-x");
1770 CmdArgs.push_back(types::getTypeName(II.getType()));
1771 }
1772
Daniel Dunbarb440f562010-08-02 02:38:21 +00001773 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001774 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00001775 else {
1776 const Arg &A = II.getInputArg();
1777
1778 // Reverse translate some rewritten options.
1779 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
1780 CmdArgs.push_back("-lstdc++");
1781 continue;
1782 }
1783
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001784 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00001785 A.render(Args, CmdArgs);
1786 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001787 }
1788
Rafael Espindolab2d0d402010-09-06 02:36:23 +00001789 const char *GCCName = getToolChain().getDriver().getCCCGenericGCCName().c_str();
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001790 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00001791 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00001792 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001793}
1794
Daniel Dunbar4e295052010-01-25 22:35:08 +00001795void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
1796 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001797 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001798}
1799
Daniel Dunbar4e295052010-01-25 22:35:08 +00001800void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
1801 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001802 // The type is good enough.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001803}
1804
Daniel Dunbar4e295052010-01-25 22:35:08 +00001805void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
1806 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001807 const Driver &D = getToolChain().getDriver();
1808
Daniel Dunbar4e295052010-01-25 22:35:08 +00001809 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00001810 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
1811 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00001812 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001813 else {
1814 if (JA.getType() != types::TY_PP_Asm)
1815 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
1816 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001817
Daniel Dunbar4e295052010-01-25 22:35:08 +00001818 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001819 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001820}
1821
Daniel Dunbar4e295052010-01-25 22:35:08 +00001822void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
1823 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001824 CmdArgs.push_back("-c");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001825}
Daniel Dunbara3246a02009-03-18 08:07:30 +00001826
Daniel Dunbar4e295052010-01-25 22:35:08 +00001827void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
1828 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00001829 // The types are (hopefully) good enough.
1830}
1831
Daniel Dunbare6adeee2009-03-29 17:08:39 +00001832const char *darwin::CC1::getCC1Name(types::ID Type) const {
1833 switch (Type) {
1834 default:
1835 assert(0 && "Unexpected type for Darwin CC1 tool.");
1836 case types::TY_Asm:
1837 case types::TY_C: case types::TY_CHeader:
1838 case types::TY_PP_C: case types::TY_PP_CHeader:
1839 return "cc1";
1840 case types::TY_ObjC: case types::TY_ObjCHeader:
1841 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader:
1842 return "cc1obj";
1843 case types::TY_CXX: case types::TY_CXXHeader:
1844 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
1845 return "cc1plus";
1846 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
1847 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader:
1848 return "cc1objplus";
1849 }
1850}
1851
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001852const char *darwin::CC1::getBaseInputName(const ArgList &Args,
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00001853 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001854 llvm::sys::Path P(Inputs[0].getBaseInput());
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00001855 return Args.MakeArgString(P.getLast());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001856}
1857
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001858const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00001859 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001860 const char *Str = getBaseInputName(Args, Inputs);
1861
1862 if (const char *End = strchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00001863 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001864
1865 return Str;
1866}
1867
1868const char *
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001869darwin::CC1::getDependencyFileName(const ArgList &Args,
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00001870 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001871 // FIXME: Think about this more.
1872 std::string Res;
1873
1874 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
1875 std::string Str(OutputOpt->getValue(Args));
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001876
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001877 Res = Str.substr(0, Str.rfind('.'));
1878 } else
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00001879 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001880
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00001881 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001882}
1883
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001884void darwin::CC1::AddCC1Args(const ArgList &Args,
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001885 ArgStringList &CmdArgs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00001886 const Driver &D = getToolChain().getDriver();
Daniel Dunbar4eadb602009-09-10 01:21:12 +00001887
1888 CheckCodeGenerationOptions(D, Args);
1889
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001890 // Derived from cc1 spec.
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001891 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
1892 !Args.hasArg(options::OPT_mdynamic_no_pic))
1893 CmdArgs.push_back("-fPIC");
1894
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00001895 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
1896 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
1897 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
1898 CmdArgs.push_back("-fno-builtin-strcat");
1899 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
1900 CmdArgs.push_back("-fno-builtin-strcpy");
1901 }
1902
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001903 // gcc has some code here to deal with when no -mmacosx-version-min
1904 // and no -miphoneos-version-min is present, but this never happens
1905 // due to tool chain specific argument translation.
1906
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001907 if (Args.hasArg(options::OPT_g_Flag) &&
1908 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
1909 CmdArgs.push_back("-feliminate-unused-debug-symbols");
1910}
1911
1912void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
1913 const InputInfoList &Inputs,
1914 const ArgStringList &OutputArgs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00001915 const Driver &D = getToolChain().getDriver();
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001916
1917 // Derived from cc1_options spec.
1918 if (Args.hasArg(options::OPT_fast) ||
1919 Args.hasArg(options::OPT_fastf) ||
1920 Args.hasArg(options::OPT_fastcp))
1921 CmdArgs.push_back("-O3");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001922
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001923 if (Arg *A = Args.getLastArg(options::OPT_pg))
1924 if (Args.hasArg(options::OPT_fomit_frame_pointer))
1925 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
1926 << A->getAsString(Args) << "-fomit-frame-pointer";
1927
1928 AddCC1Args(Args, CmdArgs);
1929
1930 if (!Args.hasArg(options::OPT_Q))
1931 CmdArgs.push_back("-quiet");
1932
1933 CmdArgs.push_back("-dumpbase");
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00001934 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001935
1936 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
1937
1938 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
1939 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
1940
1941 // FIXME: The goal is to use the user provided -o if that is our
1942 // final output, otherwise to drive from the original input
1943 // name. Find a clean way to go about this.
1944 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
1945 Args.hasArg(options::OPT_o)) {
1946 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1947 CmdArgs.push_back("-auxbase-strip");
1948 CmdArgs.push_back(OutputOpt->getValue(Args));
1949 } else {
1950 CmdArgs.push_back("-auxbase");
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00001951 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001952 }
1953
1954 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
1955
1956 Args.AddAllArgs(CmdArgs, options::OPT_O);
1957 // FIXME: -Wall is getting some special treatment. Investigate.
1958 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
1959 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001960 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001961 options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00001962 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1963 // Honor -std-default.
1964 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1965 "-std=", /*Joined=*/true);
1966 }
1967
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001968 if (Args.hasArg(options::OPT_v))
1969 CmdArgs.push_back("-version");
1970 if (Args.hasArg(options::OPT_pg))
1971 CmdArgs.push_back("-p");
1972 Args.AddLastArg(CmdArgs, options::OPT_p);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001973
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001974 // The driver treats -fsyntax-only specially.
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00001975 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
1976 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
1977 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
1978 // used to inhibit the default -fno-builtin-str{cat,cpy}.
1979 //
1980 // FIXME: Should we grow a better way to deal with "removing" args?
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001981 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
1982 options::OPT_fsyntax_only),
1983 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00001984 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
1985 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
1986 (*it)->claim();
1987 (*it)->render(Args, CmdArgs);
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00001988 }
1989 }
1990 } else
1991 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001992
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001993 Args.AddAllArgs(CmdArgs, options::OPT_undef);
1994 if (Args.hasArg(options::OPT_Qn))
1995 CmdArgs.push_back("-fno-ident");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001996
Daniel Dunbarafec1f52009-03-29 18:40:18 +00001997 // FIXME: This isn't correct.
1998 //Args.AddLastArg(CmdArgs, options::OPT__help)
1999 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
2000
2001 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2002
2003 // FIXME: Still don't get what is happening here. Investigate.
2004 Args.AddAllArgs(CmdArgs, options::OPT__param);
2005
2006 if (Args.hasArg(options::OPT_fmudflap) ||
2007 Args.hasArg(options::OPT_fmudflapth)) {
2008 CmdArgs.push_back("-fno-builtin");
2009 CmdArgs.push_back("-fno-merge-constants");
2010 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002011
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002012 if (Args.hasArg(options::OPT_coverage)) {
2013 CmdArgs.push_back("-fprofile-arcs");
2014 CmdArgs.push_back("-ftest-coverage");
2015 }
2016
2017 if (types::isCXX(Inputs[0].getType()))
2018 CmdArgs.push_back("-D__private_extern__=extern");
2019}
2020
2021void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2022 const InputInfoList &Inputs,
2023 const ArgStringList &OutputArgs) const {
2024 // Derived from cpp_options
2025 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002026
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002027 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2028
2029 AddCC1Args(Args, CmdArgs);
2030
2031 // NOTE: The code below has some commonality with cpp_options, but
2032 // in classic gcc style ends up sending things in different
2033 // orders. This may be a good merge candidate once we drop pedantic
2034 // compatibility.
2035
2036 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002037 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002038 options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002039 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2040 // Honor -std-default.
2041 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2042 "-std=", /*Joined=*/true);
2043 }
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002044 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2045 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002046
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002047 // The driver treats -fsyntax-only specially.
2048 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2049
2050 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
2051 !Args.hasArg(options::OPT_fno_working_directory))
2052 CmdArgs.push_back("-fworking-directory");
2053
2054 Args.AddAllArgs(CmdArgs, options::OPT_O);
2055 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2056 if (Args.hasArg(options::OPT_save_temps))
2057 CmdArgs.push_back("-fpch-preprocess");
2058}
2059
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002060void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002061 ArgStringList &CmdArgs,
Mike Stump11289f42009-09-09 15:08:12 +00002062 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00002063 const Driver &D = getToolChain().getDriver();
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002064
Daniel Dunbar64198ef2009-09-10 01:21:05 +00002065 CheckPreprocessingOptions(D, Args);
2066
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002067 // Derived from cpp_unique_options.
Daniel Dunbar64198ef2009-09-10 01:21:05 +00002068 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
2069 Args.AddLastArg(CmdArgs, options::OPT_C);
2070 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002071 if (!Args.hasArg(options::OPT_Q))
2072 CmdArgs.push_back("-quiet");
2073 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
Douglas Gregor64b046f2010-03-24 20:13:48 +00002074 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002075 Args.AddLastArg(CmdArgs, options::OPT_v);
2076 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
2077 Args.AddLastArg(CmdArgs, options::OPT_P);
2078
2079 // FIXME: Handle %I properly.
2080 if (getToolChain().getArchName() == "x86_64") {
2081 CmdArgs.push_back("-imultilib");
2082 CmdArgs.push_back("x86_64");
2083 }
2084
2085 if (Args.hasArg(options::OPT_MD)) {
2086 CmdArgs.push_back("-MD");
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00002087 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002088 }
2089
2090 if (Args.hasArg(options::OPT_MMD)) {
2091 CmdArgs.push_back("-MMD");
Daniel Dunbar52e96cc2009-03-30 00:34:04 +00002092 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002093 }
2094
2095 Args.AddLastArg(CmdArgs, options::OPT_M);
2096 Args.AddLastArg(CmdArgs, options::OPT_MM);
2097 Args.AddAllArgs(CmdArgs, options::OPT_MF);
2098 Args.AddLastArg(CmdArgs, options::OPT_MG);
2099 Args.AddLastArg(CmdArgs, options::OPT_MP);
2100 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
2101 Args.AddAllArgs(CmdArgs, options::OPT_MT);
2102 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
2103 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
2104 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2105 CmdArgs.push_back("-MQ");
2106 CmdArgs.push_back(OutputOpt->getValue(Args));
2107 }
2108 }
2109
2110 Args.AddLastArg(CmdArgs, options::OPT_remap);
2111 if (Args.hasArg(options::OPT_g3))
2112 CmdArgs.push_back("-dD");
2113 Args.AddLastArg(CmdArgs, options::OPT_H);
2114
2115 AddCPPArgs(Args, CmdArgs);
2116
2117 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
2118 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
2119
2120 for (InputInfoList::const_iterator
2121 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2122 const InputInfo &II = *it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002123
Daniel Dunbarb440f562010-08-02 02:38:21 +00002124 CmdArgs.push_back(II.getFilename());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002125 }
2126
2127 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
2128 options::OPT_Xpreprocessor);
2129
2130 if (Args.hasArg(options::OPT_fmudflap)) {
2131 CmdArgs.push_back("-D_MUDFLAP");
2132 CmdArgs.push_back("-include");
2133 CmdArgs.push_back("mf-runtime.h");
2134 }
2135
2136 if (Args.hasArg(options::OPT_fmudflapth)) {
2137 CmdArgs.push_back("-D_MUDFLAP");
2138 CmdArgs.push_back("-D_MUDFLAPTH");
2139 CmdArgs.push_back("-include");
2140 CmdArgs.push_back("mf-runtime.h");
2141 }
2142}
2143
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002144void darwin::CC1::AddCPPArgs(const ArgList &Args,
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002145 ArgStringList &CmdArgs) const {
2146 // Derived from cpp spec.
2147
2148 if (Args.hasArg(options::OPT_static)) {
2149 // The gcc spec is broken here, it refers to dynamic but
2150 // that has been translated. Start by being bug compatible.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002151
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002152 // if (!Args.hasArg(arglist.parser.dynamicOption))
2153 CmdArgs.push_back("-D__STATIC__");
2154 } else
2155 CmdArgs.push_back("-D__DYNAMIC__");
2156
2157 if (Args.hasArg(options::OPT_pthread))
2158 CmdArgs.push_back("-D_REENTRANT");
2159}
2160
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002161void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002162 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002163 const InputInfoList &Inputs,
2164 const ArgList &Args,
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002165 const char *LinkingOutput) const {
2166 ArgStringList CmdArgs;
2167
2168 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2169
2170 CmdArgs.push_back("-E");
2171
2172 if (Args.hasArg(options::OPT_traditional) ||
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002173 Args.hasArg(options::OPT_traditional_cpp))
2174 CmdArgs.push_back("-traditional-cpp");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002175
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002176 ArgStringList OutputArgs;
Daniel Dunbarb440f562010-08-02 02:38:21 +00002177 assert(Output.isFilename() && "Unexpected CC1 output.");
2178 OutputArgs.push_back("-o");
2179 OutputArgs.push_back(Output.getFilename());
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002180
Daniel Dunbarf64f5302009-03-29 22:27:40 +00002181 if (Args.hasArg(options::OPT_E)) {
2182 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2183 } else {
2184 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2185 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2186 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002187
Daniel Dunbar6a8803a2009-04-03 01:27:06 +00002188 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2189
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002190 const char *CC1Name = getCC1Name(Inputs[0].getType());
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002191 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002192 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002193 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002194}
2195
2196void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002197 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002198 const InputInfoList &Inputs,
2199 const ArgList &Args,
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002200 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00002201 const Driver &D = getToolChain().getDriver();
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002202 ArgStringList CmdArgs;
2203
2204 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2205
2206 types::ID InputType = Inputs[0].getType();
2207 const Arg *A;
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00002208 if ((A = Args.getLastArg(options::OPT_traditional)))
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002209 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2210 << A->getAsString(Args) << "-E";
2211
Daniel Dunbar24e52992010-06-07 23:28:45 +00002212 if (JA.getType() == types::TY_LLVM_IR ||
2213 JA.getType() == types::TY_LTO_IR)
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002214 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002215 else if (JA.getType() == types::TY_LLVM_BC ||
2216 JA.getType() == types::TY_LTO_BC)
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002217 CmdArgs.push_back("-emit-llvm-bc");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002218 else if (Output.getType() == types::TY_AST)
2219 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00002220 << getToolChain().getTripleString();
Daniel Dunbarbcd554f2010-02-11 17:33:45 +00002221 else if (JA.getType() != types::TY_PP_Asm &&
2222 JA.getType() != types::TY_PCH)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002223 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
2224 << getTypeName(JA.getType());
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002225
2226 ArgStringList OutputArgs;
2227 if (Output.getType() != types::TY_PCH) {
2228 OutputArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00002229 if (Output.isNothing())
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002230 OutputArgs.push_back("/dev/null");
2231 else
2232 OutputArgs.push_back(Output.getFilename());
2233 }
2234
2235 // There is no need for this level of compatibility, but it makes
2236 // diffing easier.
2237 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
2238 Args.hasArg(options::OPT_S));
2239
2240 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00002241 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002242 if (OutputArgsEarly) {
2243 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2244 } else {
2245 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2246 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2247 }
2248 } else {
2249 CmdArgs.push_back("-fpreprocessed");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002250
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002251 for (InputInfoList::const_iterator
2252 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2253 const InputInfo &II = *it;
2254
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002255 // Reject AST inputs.
2256 if (II.getType() == types::TY_AST) {
2257 D.Diag(clang::diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00002258 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002259 return;
2260 }
2261
Daniel Dunbarb440f562010-08-02 02:38:21 +00002262 CmdArgs.push_back(II.getFilename());
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002263 }
2264
2265 if (OutputArgsEarly) {
2266 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2267 } else {
2268 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2269 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2270 }
2271 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002272
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002273 if (Output.getType() == types::TY_PCH) {
2274 assert(Output.isFilename() && "Invalid PCH output.");
2275
2276 CmdArgs.push_back("-o");
2277 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
2278 // to be a good reason.
2279 CmdArgs.push_back("/dev/null");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002280
Daniel Dunbarf4b39e92009-11-21 02:31:29 +00002281 CmdArgs.push_back("--output-pch=");
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002282 CmdArgs.push_back(Output.getFilename());
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002283 }
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002284
2285 const char *CC1Name = getCC1Name(Inputs[0].getType());
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002286 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002287 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002288 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbare6adeee2009-03-29 17:08:39 +00002289}
2290
Daniel Dunbarbe220842009-03-20 16:06:39 +00002291void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002292 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002293 const InputInfoList &Inputs,
2294 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00002295 const char *LinkingOutput) const {
2296 ArgStringList CmdArgs;
2297
2298 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2299 const InputInfo &Input = Inputs[0];
2300
2301 // Bit of a hack, this is only used for original inputs.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002302 //
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00002303 // FIXME: This is broken for preprocessed .s inputs.
Daniel Dunbarbe220842009-03-20 16:06:39 +00002304 if (Input.isFilename() &&
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00002305 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) {
2306 if (Args.hasArg(options::OPT_gstabs))
2307 CmdArgs.push_back("--gstabs");
2308 else if (Args.hasArg(options::OPT_g_Group))
2309 CmdArgs.push_back("--gdwarf2");
2310 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002311
Daniel Dunbarbe220842009-03-20 16:06:39 +00002312 // Derived from asm spec.
Daniel Dunbar3571dd92009-09-09 18:36:27 +00002313 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00002314
Daniel Dunbar6d484762010-07-22 01:47:22 +00002315 // Use -force_cpusubtype_ALL on x86 by default.
2316 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
2317 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00002318 Args.hasArg(options::OPT_force__cpusubtype__ALL))
2319 CmdArgs.push_back("-force_cpusubtype_ALL");
2320
Daniel Dunbara6b4a3d2009-08-24 22:26:16 +00002321 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
2322 (Args.hasArg(options::OPT_mkernel) ||
Daniel Dunbarbe220842009-03-20 16:06:39 +00002323 Args.hasArg(options::OPT_static) ||
Daniel Dunbara6b4a3d2009-08-24 22:26:16 +00002324 Args.hasArg(options::OPT_fapple_kext)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002325 CmdArgs.push_back("-static");
2326
Daniel Dunbarbe220842009-03-20 16:06:39 +00002327 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2328 options::OPT_Xassembler);
2329
2330 assert(Output.isFilename() && "Unexpected lipo output.");
2331 CmdArgs.push_back("-o");
2332 CmdArgs.push_back(Output.getFilename());
2333
Daniel Dunbarb440f562010-08-02 02:38:21 +00002334 assert(Input.isFilename() && "Invalid input.");
2335 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00002336
2337 // asm_final spec is empty.
2338
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002339 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002340 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002341 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00002342}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00002343
Daniel Dunbare9ded432009-09-09 18:36:20 +00002344void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
2345 ArgStringList &CmdArgs) const {
Daniel Dunbardcc3b652010-01-22 02:04:58 +00002346 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
2347
Daniel Dunbarc1964212009-03-26 16:23:12 +00002348 // Derived from darwin_arch spec.
2349 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00002350 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00002351
Daniel Dunbardcc3b652010-01-22 02:04:58 +00002352 // FIXME: Is this needed anymore?
2353 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00002354 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00002355}
2356
Daniel Dunbarccbc4522010-09-09 21:51:05 +00002357void darwin::Link::AddLinkArgs(Compilation &C,
2358 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00002359 ArgStringList &CmdArgs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00002360 const Driver &D = getToolChain().getDriver();
Daniel Dunbarc1964212009-03-26 16:23:12 +00002361
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00002362 unsigned Version[3] = { 0, 0, 0 };
2363 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2364 bool HadExtra;
2365 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
2366 Version[1], Version[2], HadExtra) ||
2367 HadExtra)
2368 D.Diag(clang::diag::err_drv_invalid_version_number)
2369 << A->getAsString(Args);
2370 }
2371
2372 // Newer linkers support -demangle, pass it if supported and not disabled by
2373 // the user.
2374 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00002375 // Don't pass -demangle to ld_classic.
2376 //
2377 // FIXME: This is a temporary workaround, ld should be handling this.
2378 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
2379 Args.hasArg(options::OPT_static));
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00002380 if (getToolChain().getArch() == llvm::Triple::x86) {
2381 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
2382 options::OPT_Wl_COMMA),
2383 ie = Args.filtered_end(); it != ie; ++it) {
2384 const Arg *A = *it;
2385 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
2386 if (llvm::StringRef(A->getValue(Args, i)) == "-kext")
2387 UsesLdClassic = true;
2388 }
2389 }
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00002390 if (!UsesLdClassic)
2391 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00002392 }
2393
Daniel Dunbarc1964212009-03-26 16:23:12 +00002394 // Derived from the "link" spec.
2395 Args.AddAllArgs(CmdArgs, options::OPT_static);
2396 if (!Args.hasArg(options::OPT_static))
2397 CmdArgs.push_back("-dynamic");
2398 if (Args.hasArg(options::OPT_fgnu_runtime)) {
2399 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
2400 // here. How do we wish to handle such things?
2401 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002402
Daniel Dunbarc1964212009-03-26 16:23:12 +00002403 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara48823f2010-01-22 02:04:52 +00002404 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00002405 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00002406 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002407
2408 Args.AddLastArg(CmdArgs, options::OPT_bundle);
2409 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
2410 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
2411
2412 Arg *A;
2413 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
2414 (A = Args.getLastArg(options::OPT_current__version)) ||
2415 (A = Args.getLastArg(options::OPT_install__name)))
2416 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2417 << A->getAsString(Args) << "-dynamiclib";
2418
2419 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
2420 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
2421 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
2422 } else {
2423 CmdArgs.push_back("-dylib");
2424
2425 Arg *A;
2426 if ((A = Args.getLastArg(options::OPT_bundle)) ||
2427 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
2428 (A = Args.getLastArg(options::OPT_client__name)) ||
2429 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
2430 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
2431 (A = Args.getLastArg(options::OPT_private__bundle)))
2432 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2433 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002434
Daniel Dunbarc1964212009-03-26 16:23:12 +00002435 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
2436 "-dylib_compatibility_version");
2437 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
2438 "-dylib_current_version");
2439
Daniel Dunbara48823f2010-01-22 02:04:52 +00002440 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002441
2442 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
2443 "-dylib_install_name");
2444 }
2445
2446 Args.AddLastArg(CmdArgs, options::OPT_all__load);
2447 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
2448 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbar15c89422010-01-27 00:56:37 +00002449 if (getDarwinToolChain().isTargetIPhoneOS())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00002450 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002451 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
2452 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
2453 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
2454 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
2455 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
2456 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
2457 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
2458 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
2459 Args.AddAllArgs(CmdArgs, options::OPT_init);
2460
Daniel Dunbar19afd612010-01-26 03:56:40 +00002461 // Adding all arguments doesn't make sense here but this is what gcc does. One
2462 // of this should always be present thanks to argument translation.
2463 assert((Args.hasArg(options::OPT_mmacosx_version_min_EQ) ||
2464 Args.hasArg(options::OPT_miphoneos_version_min_EQ)) &&
2465 "Missing version argument (lost in translation)?");
Daniel Dunbar84e727f2009-09-04 18:35:21 +00002466 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002467 "-macosx_version_min");
Daniel Dunbarc1964212009-03-26 16:23:12 +00002468 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ,
2469 "-iphoneos_version_min");
2470 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
2471 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
2472 Args.AddLastArg(CmdArgs, options::OPT_single__module);
2473 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
2474 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002475
Daniel Dunbaraf68a882010-07-13 23:31:40 +00002476 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
2477 options::OPT_fno_pie,
2478 options::OPT_fno_PIE)) {
2479 if (A->getOption().matches(options::OPT_fpie) ||
2480 A->getOption().matches(options::OPT_fPIE))
2481 CmdArgs.push_back("-pie");
2482 else
2483 CmdArgs.push_back("-no_pie");
2484 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00002485
2486 Args.AddLastArg(CmdArgs, options::OPT_prebind);
2487 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
2488 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
2489 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
2490 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
2491 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
2492 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
2493 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
2494 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
2495 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
2496 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
2497 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
2498 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
2499 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
2500 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
2501 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00002502
Daniel Dunbarc1964212009-03-26 16:23:12 +00002503 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot");
Daniel Dunbar15c89422010-01-27 00:56:37 +00002504 if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00002505 if (!Args.hasArg(options::OPT_isysroot)) {
2506 CmdArgs.push_back("-syslibroot");
2507 CmdArgs.push_back("/Developer/SDKs/Extra");
2508 }
2509 }
2510
Daniel Dunbarc1964212009-03-26 16:23:12 +00002511 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
2512 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
2513 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
2514 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
2515 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00002516 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002517 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
2518 Args.AddAllArgs(CmdArgs, options::OPT_y);
2519 Args.AddLastArg(CmdArgs, options::OPT_w);
2520 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
2521 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
2522 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
2523 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
2524 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
2525 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
2526 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
2527 Args.AddLastArg(CmdArgs, options::OPT_whyload);
2528 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
2529 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
2530 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
2531 Args.AddLastArg(CmdArgs, options::OPT_Mach);
2532}
2533
2534void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002535 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002536 const InputInfoList &Inputs,
2537 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00002538 const char *LinkingOutput) const {
2539 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00002540
Daniel Dunbarc1964212009-03-26 16:23:12 +00002541 // The logic here is derived from gcc's behavior; most of which
2542 // comes from specs (starting with link_command). Consult gcc for
2543 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00002544 ArgStringList CmdArgs;
2545
2546 // I'm not sure why this particular decomposition exists in gcc, but
2547 // we follow suite for ease of comparison.
Daniel Dunbarccbc4522010-09-09 21:51:05 +00002548 AddLinkArgs(C, Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002549
Daniel Dunbarc1964212009-03-26 16:23:12 +00002550 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
2551 Args.AddAllArgs(CmdArgs, options::OPT_s);
2552 Args.AddAllArgs(CmdArgs, options::OPT_t);
2553 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
2554 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
2555 Args.AddAllArgs(CmdArgs, options::OPT_A);
2556 Args.AddLastArg(CmdArgs, options::OPT_e);
2557 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
2558 Args.AddAllArgs(CmdArgs, options::OPT_r);
2559
Daniel Dunbar767bbab2010-10-18 22:08:36 +00002560 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
2561 // members of static archive libraries which implement Objective-C classes or
2562 // categories.
2563 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
2564 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002565
Daniel Dunbarc1964212009-03-26 16:23:12 +00002566 CmdArgs.push_back("-o");
2567 CmdArgs.push_back(Output.getFilename());
2568
Daniel Dunbarc1964212009-03-26 16:23:12 +00002569 if (!Args.hasArg(options::OPT_A) &&
2570 !Args.hasArg(options::OPT_nostdlib) &&
2571 !Args.hasArg(options::OPT_nostartfiles)) {
2572 // Derived from startfile spec.
2573 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002574 // Derived from darwin_dylib1 spec.
Daniel Dunbar83608032010-01-27 00:56:56 +00002575 if (getDarwinToolChain().isTargetIPhoneOS()) {
2576 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
2577 CmdArgs.push_back("-ldylib1.o");
2578 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00002579 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbar83608032010-01-27 00:56:56 +00002580 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00002581 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00002582 CmdArgs.push_back("-ldylib1.10.5.o");
2583 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00002584 } else {
2585 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbarae8bca02009-04-01 03:17:40 +00002586 if (!Args.hasArg(options::OPT_static)) {
2587 // Derived from darwin_bundle1 spec.
Daniel Dunbar83608032010-01-27 00:56:56 +00002588 if (getDarwinToolChain().isTargetIPhoneOS()) {
2589 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
2590 CmdArgs.push_back("-lbundle1.o");
2591 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00002592 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00002593 CmdArgs.push_back("-lbundle1.o");
2594 }
Daniel Dunbarae8bca02009-04-01 03:17:40 +00002595 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00002596 } else {
2597 if (Args.hasArg(options::OPT_pg)) {
2598 if (Args.hasArg(options::OPT_static) ||
2599 Args.hasArg(options::OPT_object) ||
2600 Args.hasArg(options::OPT_preload)) {
2601 CmdArgs.push_back("-lgcrt0.o");
2602 } else {
2603 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002604
Daniel Dunbarc1964212009-03-26 16:23:12 +00002605 // darwin_crt2 spec is empty.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002606 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00002607 } else {
2608 if (Args.hasArg(options::OPT_static) ||
2609 Args.hasArg(options::OPT_object) ||
2610 Args.hasArg(options::OPT_preload)) {
2611 CmdArgs.push_back("-lcrt0.o");
2612 } else {
2613 // Derived from darwin_crt1 spec.
Daniel Dunbar15c89422010-01-27 00:56:37 +00002614 if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00002615 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
2616 CmdArgs.push_back("-lcrt1.o");
2617 else
2618 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00002619 } else {
2620 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
2621 CmdArgs.push_back("-lcrt1.o");
2622 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
2623 CmdArgs.push_back("-lcrt1.10.5.o");
2624 else
2625 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002626
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00002627 // darwin_crt2 spec is empty.
2628 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00002629 }
2630 }
2631 }
2632 }
2633
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00002634 if (!getDarwinToolChain().isTargetIPhoneOS() &&
2635 Args.hasArg(options::OPT_shared_libgcc) &&
2636 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00002637 const char *Str =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002638 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00002639 CmdArgs.push_back(Str);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002640 }
2641 }
2642
2643 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002644
Daniel Dunbarc1964212009-03-26 16:23:12 +00002645 if (Args.hasArg(options::OPT_fopenmp))
2646 // This is more complicated in gcc...
2647 CmdArgs.push_back("-lgomp");
2648
Daniel Dunbar4c30b892009-09-18 08:14:36 +00002649 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002650
Daniel Dunbar54423b22010-09-17 00:24:54 +00002651 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002652
2653 if (LinkingOutput) {
2654 CmdArgs.push_back("-arch_multiple");
2655 CmdArgs.push_back("-final_output");
2656 CmdArgs.push_back(LinkingOutput);
2657 }
2658
2659 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2660 Args.hasArg(options::OPT_fprofile_generate) ||
2661 Args.hasArg(options::OPT_fcreate_profile) ||
2662 Args.hasArg(options::OPT_coverage))
2663 CmdArgs.push_back("-lgcov");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002664
Daniel Dunbarc1964212009-03-26 16:23:12 +00002665 if (Args.hasArg(options::OPT_fnested_functions))
2666 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002667
Daniel Dunbarc1964212009-03-26 16:23:12 +00002668 if (!Args.hasArg(options::OPT_nostdlib) &&
2669 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar083edf72009-12-21 18:54:17 +00002670 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00002671 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00002672
Daniel Dunbarc1964212009-03-26 16:23:12 +00002673 // link_ssp spec is empty.
2674
Daniel Dunbar26d482a2009-09-18 08:15:03 +00002675 // Let the tool chain choose which runtime library to link.
2676 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00002677 }
2678
2679 if (!Args.hasArg(options::OPT_A) &&
2680 !Args.hasArg(options::OPT_nostdlib) &&
2681 !Args.hasArg(options::OPT_nostartfiles)) {
2682 // endfile_spec is empty.
2683 }
2684
2685 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
2686 Args.AddAllArgs(CmdArgs, options::OPT_F);
2687
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002688 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002689 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002690 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00002691}
2692
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00002693void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002694 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002695 const InputInfoList &Inputs,
2696 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00002697 const char *LinkingOutput) const {
2698 ArgStringList CmdArgs;
2699
2700 CmdArgs.push_back("-create");
2701 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00002702
2703 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00002704 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00002705
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00002706 for (InputInfoList::const_iterator
2707 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2708 const InputInfo &II = *it;
2709 assert(II.isFilename() && "Unexpected lipo input.");
2710 CmdArgs.push_back(II.getFilename());
2711 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002712 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002713 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002714 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00002715}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002716
Daniel Dunbar88299622010-06-04 18:28:36 +00002717void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002718 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00002719 const InputInfoList &Inputs,
2720 const ArgList &Args,
2721 const char *LinkingOutput) const {
2722 ArgStringList CmdArgs;
2723
2724 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2725 const InputInfo &Input = Inputs[0];
2726 assert(Input.isFilename() && "Unexpected dsymutil input.");
2727 CmdArgs.push_back(Input.getFilename());
2728
2729 CmdArgs.push_back("-o");
2730 CmdArgs.push_back(Output.getFilename());
2731
2732 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002733 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002734 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00002735}
2736
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002737void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002738 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002739 const InputInfoList &Inputs,
2740 const ArgList &Args,
2741 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002742 ArgStringList CmdArgs;
2743
2744 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2745 options::OPT_Xassembler);
2746
2747 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00002748 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002749
2750 for (InputInfoList::const_iterator
2751 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2752 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00002753 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002754 }
2755
2756 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002757 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002758 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002759}
2760
2761void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002762 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002763 const InputInfoList &Inputs,
2764 const ArgList &Args,
2765 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002766 ArgStringList CmdArgs;
2767
2768 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002769 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002770 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00002771 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002772 }
2773
2774 if (Args.hasArg(options::OPT_static)) {
2775 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00002776 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002777 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00002778// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002779 CmdArgs.push_back("-Bdynamic");
2780 if (Args.hasArg(options::OPT_shared)) {
2781 CmdArgs.push_back("-shared");
2782 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00002783 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002784 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
2785 }
2786 }
2787
Daniel Dunbarb440f562010-08-02 02:38:21 +00002788 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002789 CmdArgs.push_back("-o");
2790 CmdArgs.push_back(Output.getFilename());
2791 } else {
2792 assert(Output.isNothing() && "Invalid output.");
2793 }
2794
2795 if (!Args.hasArg(options::OPT_nostdlib) &&
2796 !Args.hasArg(options::OPT_nostartfiles)) {
2797 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00002798 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002799 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00002800 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002801 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00002802 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002803 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002804 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00002805 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002806 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002807 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00002808 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002809 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002810 }
2811
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002812 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
2813 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00002814 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002815
2816 Args.AddAllArgs(CmdArgs, options::OPT_L);
2817 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
2818 Args.AddAllArgs(CmdArgs, options::OPT_e);
2819
Daniel Dunbar54423b22010-09-17 00:24:54 +00002820 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002821
2822 if (!Args.hasArg(options::OPT_nostdlib) &&
2823 !Args.hasArg(options::OPT_nodefaultlibs)) {
2824 // FIXME: For some reason GCC passes -lgcc before adding
2825 // the default system libraries. Just mimic this for now.
2826 CmdArgs.push_back("-lgcc");
2827
2828 if (Args.hasArg(options::OPT_pthread))
2829 CmdArgs.push_back("-pthread");
2830 if (!Args.hasArg(options::OPT_shared))
2831 CmdArgs.push_back("-lc");
2832 CmdArgs.push_back("-lgcc");
2833 }
2834
2835 if (!Args.hasArg(options::OPT_nostdlib) &&
2836 !Args.hasArg(options::OPT_nostartfiles)) {
2837 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00002838 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002839 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002840 }
2841
2842 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002843 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002844 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00002845}
2846
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002847void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002848 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002849 const InputInfoList &Inputs,
2850 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00002851 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002852 ArgStringList CmdArgs;
2853
2854 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2855 options::OPT_Xassembler);
2856
2857 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00002858 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002859
2860 for (InputInfoList::const_iterator
2861 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2862 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00002863 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002864 }
2865
2866 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002867 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002868 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002869}
2870
2871void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002872 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002873 const InputInfoList &Inputs,
2874 const ArgList &Args,
2875 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00002876 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002877 ArgStringList CmdArgs;
2878
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002879 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002880 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002881 CmdArgs.push_back("-e");
2882 CmdArgs.push_back("__start");
2883 }
2884
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002885 if (Args.hasArg(options::OPT_static)) {
2886 CmdArgs.push_back("-Bstatic");
2887 } else {
2888 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002889 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002890 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002891 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002892 } else {
2893 CmdArgs.push_back("-dynamic-linker");
2894 CmdArgs.push_back("/usr/libexec/ld.so");
2895 }
2896 }
2897
Daniel Dunbarb440f562010-08-02 02:38:21 +00002898 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002899 CmdArgs.push_back("-o");
2900 CmdArgs.push_back(Output.getFilename());
2901 } else {
2902 assert(Output.isNothing() && "Invalid output.");
2903 }
2904
2905 if (!Args.hasArg(options::OPT_nostdlib) &&
2906 !Args.hasArg(options::OPT_nostartfiles)) {
2907 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00002908 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002909 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00002910 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002911 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002912 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00002913 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002914 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002915 }
2916 }
2917
Edward O'Callaghan5c521462009-10-28 15:13:08 +00002918 std::string Triple = getToolChain().getTripleString();
2919 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002920 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00002921 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00002922 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002923
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002924 Args.AddAllArgs(CmdArgs, options::OPT_L);
2925 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
2926 Args.AddAllArgs(CmdArgs, options::OPT_e);
2927
Daniel Dunbar54423b22010-09-17 00:24:54 +00002928 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002929
2930 if (!Args.hasArg(options::OPT_nostdlib) &&
2931 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbarea3813f2010-08-01 23:13:54 +00002932 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00002933 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarea3813f2010-08-01 23:13:54 +00002934 CmdArgs.push_back("-lm");
2935 }
2936
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002937 // FIXME: For some reason GCC passes -lgcc before adding
2938 // the default system libraries. Just mimic this for now.
2939 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002940
2941 if (Args.hasArg(options::OPT_pthread))
2942 CmdArgs.push_back("-pthread");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00002943 if (!Args.hasArg(options::OPT_shared))
2944 CmdArgs.push_back("-lc");
2945 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002946 }
2947
2948 if (!Args.hasArg(options::OPT_nostdlib) &&
2949 !Args.hasArg(options::OPT_nostartfiles)) {
2950 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00002951 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002952 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002953 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00002954 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002955 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002956 }
2957
2958 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002959 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002960 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002961}
Ed Schoutene33194b2009-04-02 19:13:12 +00002962
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002963void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002964 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002965 const InputInfoList &Inputs,
2966 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00002967 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002968 ArgStringList CmdArgs;
2969
Daniel Dunbard854c8d2009-04-01 19:36:32 +00002970 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
2971 // instruct as in the base system to assemble 32-bit code.
2972 if (getToolChain().getArchName() == "i386")
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002973 CmdArgs.push_back("--32");
2974
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002975
Eric Christopher0b26a612010-03-02 02:41:08 +00002976 // Set byte order explicitly
2977 if (getToolChain().getArchName() == "mips")
2978 CmdArgs.push_back("-EB");
2979 else if (getToolChain().getArchName() == "mipsel")
2980 CmdArgs.push_back("-EL");
2981
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002982 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2983 options::OPT_Xassembler);
2984
2985 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00002986 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002987
2988 for (InputInfoList::const_iterator
2989 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2990 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00002991 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002992 }
2993
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002994 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00002995 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00002996 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00002997}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00002998
2999void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003000 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003001 const InputInfoList &Inputs,
3002 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003003 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003004 const Driver &D = getToolChain().getDriver();
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003005 ArgStringList CmdArgs;
3006
3007 if (Args.hasArg(options::OPT_static)) {
3008 CmdArgs.push_back("-Bstatic");
3009 } else {
3010 CmdArgs.push_back("--eh-frame-hdr");
3011 if (Args.hasArg(options::OPT_shared)) {
3012 CmdArgs.push_back("-Bshareable");
3013 } else {
3014 CmdArgs.push_back("-dynamic-linker");
3015 CmdArgs.push_back("/libexec/ld-elf.so.1");
3016 }
3017 }
3018
3019 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3020 // instruct ld in the base system to link 32-bit code.
3021 if (getToolChain().getArchName() == "i386") {
3022 CmdArgs.push_back("-m");
3023 CmdArgs.push_back("elf_i386_fbsd");
3024 }
3025
Daniel Dunbarb440f562010-08-02 02:38:21 +00003026 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003027 CmdArgs.push_back("-o");
3028 CmdArgs.push_back(Output.getFilename());
3029 } else {
3030 assert(Output.isNothing() && "Invalid output.");
3031 }
3032
3033 if (!Args.hasArg(options::OPT_nostdlib) &&
3034 !Args.hasArg(options::OPT_nostartfiles)) {
3035 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003036 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003037 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003038 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003039 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003040 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003041 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003042 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003043 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003044 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003045 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003046 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003047 }
3048 }
3049
3050 Args.AddAllArgs(CmdArgs, options::OPT_L);
3051 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3052 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00003053 Args.AddAllArgs(CmdArgs, options::OPT_s);
3054 Args.AddAllArgs(CmdArgs, options::OPT_t);
3055 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3056 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003057
Daniel Dunbar54423b22010-09-17 00:24:54 +00003058 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003059
3060 if (!Args.hasArg(options::OPT_nostdlib) &&
3061 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00003062 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00003063 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00003064 CmdArgs.push_back("-lm");
3065 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003066 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3067 // the default system libraries. Just mimic this for now.
3068 CmdArgs.push_back("-lgcc");
3069 if (Args.hasArg(options::OPT_static)) {
3070 CmdArgs.push_back("-lgcc_eh");
3071 } else {
3072 CmdArgs.push_back("--as-needed");
3073 CmdArgs.push_back("-lgcc_s");
3074 CmdArgs.push_back("--no-as-needed");
3075 }
3076
3077 if (Args.hasArg(options::OPT_pthread))
3078 CmdArgs.push_back("-lpthread");
3079 CmdArgs.push_back("-lc");
3080
3081 CmdArgs.push_back("-lgcc");
3082 if (Args.hasArg(options::OPT_static)) {
3083 CmdArgs.push_back("-lgcc_eh");
3084 } else {
3085 CmdArgs.push_back("--as-needed");
3086 CmdArgs.push_back("-lgcc_s");
3087 CmdArgs.push_back("--no-as-needed");
3088 }
3089 }
3090
3091 if (!Args.hasArg(options::OPT_nostdlib) &&
3092 !Args.hasArg(options::OPT_nostartfiles)) {
3093 if (!Args.hasArg(options::OPT_shared))
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003094 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner3e2ee142010-07-07 16:01:42 +00003095 "crtend.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003096 else
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003097 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner3e2ee142010-07-07 16:01:42 +00003098 "crtendS.o")));
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003099 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner3e2ee142010-07-07 16:01:42 +00003100 "crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003101 }
3102
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003103 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003104 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003105 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00003106}
Daniel Dunbarcc912342009-05-02 18:28:39 +00003107
Rafael Espindola92b00932010-08-10 00:25:48 +00003108void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3109 const InputInfo &Output,
3110 const InputInfoList &Inputs,
3111 const ArgList &Args,
3112 const char *LinkingOutput) const {
3113 ArgStringList CmdArgs;
3114
3115 // Add --32/--64 to make sure we get the format we want.
3116 // This is incomplete
3117 if (getToolChain().getArch() == llvm::Triple::x86) {
3118 CmdArgs.push_back("--32");
3119 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
3120 CmdArgs.push_back("--64");
3121 } else if (getToolChain().getArch() == llvm::Triple::arm) {
3122 llvm::StringRef MArch = getToolChain().getArchName();
3123 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
3124 CmdArgs.push_back("-mfpu=neon");
3125 }
3126
3127 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3128 options::OPT_Xassembler);
3129
3130 CmdArgs.push_back("-o");
3131 CmdArgs.push_back(Output.getFilename());
3132
3133 for (InputInfoList::const_iterator
3134 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3135 const InputInfo &II = *it;
3136 CmdArgs.push_back(II.getFilename());
3137 }
3138
3139 const char *Exec =
3140 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3141 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3142}
3143
3144
Chris Lattner3e2ee142010-07-07 16:01:42 +00003145void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003146 const InputInfo &Output,
3147 const InputInfoList &Inputs,
3148 const ArgList &Args,
3149 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003150 ArgStringList CmdArgs;
3151
3152 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3153 options::OPT_Xassembler);
3154
3155 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00003156 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00003157
3158 for (InputInfoList::const_iterator
3159 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3160 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00003161 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00003162 }
3163
3164 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003165 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003166 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003167}
3168
3169void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003170 const InputInfo &Output,
3171 const InputInfoList &Inputs,
3172 const ArgList &Args,
3173 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003174 const Driver &D = getToolChain().getDriver();
3175 ArgStringList CmdArgs;
3176
Daniel Dunbarb440f562010-08-02 02:38:21 +00003177 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003178 CmdArgs.push_back("-o");
3179 CmdArgs.push_back(Output.getFilename());
3180 } else {
3181 assert(Output.isNothing() && "Invalid output.");
3182 }
3183
3184 if (!Args.hasArg(options::OPT_nostdlib) &&
3185 !Args.hasArg(options::OPT_nostartfiles))
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003186 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner3e2ee142010-07-07 16:01:42 +00003187 "/usr/gnu/lib/crtso.o")));
3188
3189 Args.AddAllArgs(CmdArgs, options::OPT_L);
3190 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3191 Args.AddAllArgs(CmdArgs, options::OPT_e);
3192
Daniel Dunbar54423b22010-09-17 00:24:54 +00003193 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00003194
3195 if (!Args.hasArg(options::OPT_nostdlib) &&
3196 !Args.hasArg(options::OPT_nodefaultlibs)) {
3197 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00003198 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00003199 CmdArgs.push_back("-lm");
3200 }
3201
3202 if (Args.hasArg(options::OPT_pthread))
3203 CmdArgs.push_back("-lpthread");
3204 CmdArgs.push_back("-lc");
3205 CmdArgs.push_back("-lgcc");
3206 CmdArgs.push_back("-L/usr/gnu/lib");
3207 // FIXME: fill in the correct search path for the final
3208 // support libraries.
3209 CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
3210 }
3211
3212 if (!Args.hasArg(options::OPT_nostdlib) &&
3213 !Args.hasArg(options::OPT_nostartfiles)) {
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003214 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
Chris Lattner3e2ee142010-07-07 16:01:42 +00003215 "/usr/gnu/lib/libend.a")));
3216 }
3217
3218 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003219 Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003220 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003221}
3222
Daniel Dunbarcc912342009-05-02 18:28:39 +00003223/// DragonFly Tools
3224
3225// For now, DragonFly Assemble does just about the same as for
3226// FreeBSD, but this may change soon.
3227void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003228 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003229 const InputInfoList &Inputs,
3230 const ArgList &Args,
3231 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00003232 ArgStringList CmdArgs;
3233
3234 // When building 32-bit code on DragonFly/pc64, we have to explicitly
3235 // instruct as in the base system to assemble 32-bit code.
3236 if (getToolChain().getArchName() == "i386")
3237 CmdArgs.push_back("--32");
3238
3239 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3240 options::OPT_Xassembler);
3241
3242 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00003243 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00003244
3245 for (InputInfoList::const_iterator
3246 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3247 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00003248 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00003249 }
3250
3251 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003252 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003253 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00003254}
3255
3256void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003257 const InputInfo &Output,
3258 const InputInfoList &Inputs,
3259 const ArgList &Args,
3260 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003261 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00003262 ArgStringList CmdArgs;
3263
3264 if (Args.hasArg(options::OPT_static)) {
3265 CmdArgs.push_back("-Bstatic");
3266 } else {
3267 if (Args.hasArg(options::OPT_shared))
3268 CmdArgs.push_back("-Bshareable");
3269 else {
3270 CmdArgs.push_back("-dynamic-linker");
3271 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
3272 }
3273 }
3274
3275 // When building 32-bit code on DragonFly/pc64, we have to explicitly
3276 // instruct ld in the base system to link 32-bit code.
3277 if (getToolChain().getArchName() == "i386") {
3278 CmdArgs.push_back("-m");
3279 CmdArgs.push_back("elf_i386");
3280 }
3281
Daniel Dunbarb440f562010-08-02 02:38:21 +00003282 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00003283 CmdArgs.push_back("-o");
3284 CmdArgs.push_back(Output.getFilename());
3285 } else {
3286 assert(Output.isNothing() && "Invalid output.");
3287 }
3288
3289 if (!Args.hasArg(options::OPT_nostdlib) &&
3290 !Args.hasArg(options::OPT_nostartfiles)) {
3291 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003292 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003293 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003294 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003295 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003296 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003297 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00003298 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00003299 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003300 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003301 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003302 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00003303 }
3304 }
3305
3306 Args.AddAllArgs(CmdArgs, options::OPT_L);
3307 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3308 Args.AddAllArgs(CmdArgs, options::OPT_e);
3309
Daniel Dunbar54423b22010-09-17 00:24:54 +00003310 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00003311
3312 if (!Args.hasArg(options::OPT_nostdlib) &&
3313 !Args.hasArg(options::OPT_nodefaultlibs)) {
3314 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
3315 // rpaths
3316 CmdArgs.push_back("-L/usr/lib/gcc41");
3317
3318 if (!Args.hasArg(options::OPT_static)) {
3319 CmdArgs.push_back("-rpath");
3320 CmdArgs.push_back("/usr/lib/gcc41");
3321
3322 CmdArgs.push_back("-rpath-link");
3323 CmdArgs.push_back("/usr/lib/gcc41");
3324
3325 CmdArgs.push_back("-rpath");
3326 CmdArgs.push_back("/usr/lib");
3327
3328 CmdArgs.push_back("-rpath-link");
3329 CmdArgs.push_back("/usr/lib");
3330 }
3331
Rafael Espindola38360b32010-07-20 12:59:03 +00003332 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00003333 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00003334 CmdArgs.push_back("-lm");
3335 }
3336
Daniel Dunbarcc912342009-05-02 18:28:39 +00003337 if (Args.hasArg(options::OPT_shared)) {
3338 CmdArgs.push_back("-lgcc_pic");
3339 } else {
3340 CmdArgs.push_back("-lgcc");
3341 }
3342
3343
3344 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00003345 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00003346
3347 if (!Args.hasArg(options::OPT_nolibc)) {
3348 CmdArgs.push_back("-lc");
3349 }
3350
3351 if (Args.hasArg(options::OPT_shared)) {
3352 CmdArgs.push_back("-lgcc_pic");
3353 } else {
3354 CmdArgs.push_back("-lgcc");
3355 }
3356 }
3357
3358 if (!Args.hasArg(options::OPT_nostdlib) &&
3359 !Args.hasArg(options::OPT_nostartfiles)) {
3360 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00003361 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003362 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00003363 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00003364 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003365 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00003366 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003367 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00003368 }
3369
3370 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003371 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003372 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00003373}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00003374
3375void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
3376 const InputInfo &Output,
3377 const InputInfoList &Inputs,
3378 const ArgList &Args,
3379 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00003380 ArgStringList CmdArgs;
3381
3382 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00003383 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
3384 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00003385 } else {
3386 assert(Output.isNothing() && "Invalid output.");
3387 }
3388
3389 if (!Args.hasArg(options::OPT_nostdlib) &&
3390 !Args.hasArg(options::OPT_nostartfiles)) {
3391 CmdArgs.push_back("-defaultlib:libcmt");
3392 }
3393
3394 CmdArgs.push_back("-nologo");
3395
Daniel Dunbar54423b22010-09-17 00:24:54 +00003396 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00003397
3398 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00003399 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00003400 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3401}