1//===--- Tools.cpp - Tools Implementations --------------------------------===//
2//
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
12#include "clang/Driver/Action.h"
13#include "clang/Driver/Arg.h"
14#include "clang/Driver/ArgList.h"
15#include "clang/Driver/Driver.h"
16#include "clang/Driver/DriverDiagnostic.h"
17#include "clang/Driver/Compilation.h"
18#include "clang/Driver/Job.h"
19#include "clang/Driver/HostInfo.h"
20#include "clang/Driver/Option.h"
21#include "clang/Driver/Options.h"
22#include "clang/Driver/ToolChain.h"
23#include "clang/Driver/Util.h"
24
25#include "llvm/ADT/SmallString.h"
26#include "llvm/ADT/StringSwitch.h"
27#include "llvm/ADT/Twine.h"
28#include "llvm/Support/FileSystem.h"
29#include "llvm/Support/Format.h"
30#include "llvm/Support/raw_ostream.h"
31#include "llvm/Support/Host.h"
32#include "llvm/Support/Process.h"
33
34#include "InputInfo.h"
35#include "ToolChains.h"
36
37using namespace clang::driver;
38using namespace clang::driver::tools;
39
40/// CheckPreprocessingOptions - Perform some validation of preprocessing
41/// arguments that is shared with gcc.
42static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
43 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
44 if (!Args.hasArg(options::OPT_E))
45 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
46 << A->getAsString(Args) << "-E";
47}
48
49/// CheckCodeGenerationOptions - Perform some validation of code generation
50/// arguments that is shared with gcc.
51static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
52 // In gcc, only ARM checks this, but it seems reasonable to check universally.
53 if (Args.hasArg(options::OPT_static))
54 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
55 options::OPT_mdynamic_no_pic))
56 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
57 << A->getAsString(Args) << "-static";
58}
59
60// Quote target names for inclusion in GNU Make dependency files.
61// Only the characters '$', '#', ' ', '\t' are quoted.
62static void QuoteTarget(llvm::StringRef Target,
63 llvm::SmallVectorImpl<char> &Res) {
64 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
65 switch (Target[i]) {
66 case ' ':
67 case '\t':
68 // Escape the preceding backslashes
69 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
70 Res.push_back('\\');
71
72 // Escape the space/tab
73 Res.push_back('\\');
74 break;
75 case '$':
76 Res.push_back('$');
77 break;
78 case '#':
79 Res.push_back('\\');
80 break;
81 default:
82 break;
83 }
84
85 Res.push_back(Target[i]);
86 }
87}
88
89static void AddLinkerInputs(const ToolChain &TC,
90 const InputInfoList &Inputs, const ArgList &Args,
91 ArgStringList &CmdArgs) {
92 const Driver &D = TC.getDriver();
93
94 // Add extra linker input arguments which are not treated as inputs
95 // (constructed via -Xarch_).
96 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
97
98 for (InputInfoList::const_iterator
99 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
100 const InputInfo &II = *it;
101
102 if (!TC.HasNativeLLVMSupport()) {
103 // Don't try to pass LLVM inputs unless we have native support.
104 if (II.getType() == types::TY_LLVM_IR ||
105 II.getType() == types::TY_LTO_IR ||
106 II.getType() == types::TY_LLVM_BC ||
107 II.getType() == types::TY_LTO_BC)
108 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
109 << TC.getTripleString();
110 }
111
112 // Add filenames immediately.
113 if (II.isFilename()) {
114 CmdArgs.push_back(II.getFilename());
115 continue;
116 }
117
118 // Otherwise, this is a linker input argument.
119 const Arg &A = II.getInputArg();
120
121 // Handle reserved library options.
122 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
123 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
124 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
125 TC.AddCCKextLibArgs(Args, CmdArgs);
126 } else
127 A.renderAsInput(Args, CmdArgs);
128 }
129}
130
131void Clang::AddPreprocessingOptions(const Driver &D,
132 const ArgList &Args,
133 ArgStringList &CmdArgs,
134 const InputInfo &Output,
135 const InputInfoList &Inputs) const {
136 Arg *A;
137
138 CheckPreprocessingOptions(D, Args);
139
140 Args.AddLastArg(CmdArgs, options::OPT_C);
141 Args.AddLastArg(CmdArgs, options::OPT_CC);
142
143 // Handle dependency file generation.
144 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
145 (A = Args.getLastArg(options::OPT_MD)) ||
146 (A = Args.getLastArg(options::OPT_MMD))) {
147 // Determine the output location.
148 const char *DepFile;
149 if (Output.getType() == types::TY_Dependencies) {
150 DepFile = Output.getFilename();
151 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
152 DepFile = MF->getValue(Args);
153 } else if (A->getOption().matches(options::OPT_M) ||
154 A->getOption().matches(options::OPT_MM)) {
155 DepFile = "-";
156 } else {
157 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
158 }
159 CmdArgs.push_back("-dependency-file");
160 CmdArgs.push_back(DepFile);
161
162 // Add a default target if one wasn't specified.
163 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
164 const char *DepTarget;
165
166 // If user provided -o, that is the dependency target, except
167 // when we are only generating a dependency file.
168 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
169 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
170 DepTarget = OutputOpt->getValue(Args);
171 } else {
172 // Otherwise derive from the base input.
173 //
174 // FIXME: This should use the computed output file location.
175 llvm::SmallString<128> P(Inputs[0].getBaseInput());
176 llvm::sys::path::replace_extension(P, "o");
177 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
178 }
179
180 CmdArgs.push_back("-MT");
181 llvm::SmallString<128> Quoted;
182 QuoteTarget(DepTarget, Quoted);
183 CmdArgs.push_back(Args.MakeArgString(Quoted));
184 }
185
186 if (A->getOption().matches(options::OPT_M) ||
187 A->getOption().matches(options::OPT_MD))
188 CmdArgs.push_back("-sys-header-deps");
189 }
190
191 Args.AddLastArg(CmdArgs, options::OPT_MP);
192
193 // Convert all -MQ <target> args to -MT <quoted target>
194 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
195 options::OPT_MQ),
196 ie = Args.filtered_end(); it != ie; ++it) {
197 const Arg *A = *it;
198 A->claim();
199
200 if (A->getOption().matches(options::OPT_MQ)) {
201 CmdArgs.push_back("-MT");
202 llvm::SmallString<128> Quoted;
203 QuoteTarget(A->getValue(Args), Quoted);
204 CmdArgs.push_back(Args.MakeArgString(Quoted));
205
206 // -MT flag - no change
207 } else {
208 A->render(Args, CmdArgs);
209 }
210 }
211
212 // Add -i* options, and automatically translate to
213 // -include-pch/-include-pth for transparent PCH support. It's
214 // wonky, but we include looking for .gch so we can support seamless
215 // replacement into a build system already set up to be generating
216 // .gch files.
217 bool RenderedImplicitInclude = false;
218 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
219 ie = Args.filtered_end(); it != ie; ++it) {
220 const Arg *A = it;
221
222 if (A->getOption().matches(options::OPT_include)) {
223 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
224 RenderedImplicitInclude = true;
225
226 // Use PCH if the user requested it.
227 bool UsePCH = D.CCCUsePCH;
228
229 bool FoundPTH = false;
230 bool FoundPCH = false;
231 llvm::sys::Path P(A->getValue(Args));
232 bool Exists;
233 if (UsePCH) {
234 P.appendSuffix("pch");
235 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
236 FoundPCH = true;
237 else
238 P.eraseSuffix();
239 }
240
241 if (!FoundPCH) {
242 P.appendSuffix("pth");
243 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
244 FoundPTH = true;
245 else
246 P.eraseSuffix();
247 }
248
249 if (!FoundPCH && !FoundPTH) {
250 P.appendSuffix("gch");
251 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
252 FoundPCH = UsePCH;
253 FoundPTH = !UsePCH;
254 }
255 else
256 P.eraseSuffix();
257 }
258
259 if (FoundPCH || FoundPTH) {
260 if (IsFirstImplicitInclude) {
261 A->claim();
262 if (UsePCH)
263 CmdArgs.push_back("-include-pch");
264 else
265 CmdArgs.push_back("-include-pth");
266 CmdArgs.push_back(Args.MakeArgString(P.str()));
267 continue;
268 } else {
269 // Ignore the PCH if not first on command line and emit warning.
270 D.Diag(clang::diag::warn_drv_pch_not_first_include)
271 << P.str() << A->getAsString(Args);
272 }
273 }
274 }
275
276 // Not translated, render as usual.
277 A->claim();
278 A->render(Args, CmdArgs);
279 }
280
281 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
282 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
283
284 // Add C++ include arguments, if needed.
285 types::ID InputType = Inputs[0].getType();
286 if (types::isCXX(InputType))
287 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
288
289 // Add -Wp, and -Xassembler if using the preprocessor.
290
291 // FIXME: There is a very unfortunate problem here, some troubled
292 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
293 // really support that we would have to parse and then translate
294 // those options. :(
295 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
296 options::OPT_Xpreprocessor);
297
298 // -I- is a deprecated GCC feature, reject it.
299 if (Arg *A = Args.getLastArg(options::OPT_I_))
300 D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
301
302 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
303 // -isysroot to the CC1 invocation.
304 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
305 if (!Args.hasArg(options::OPT_isysroot)) {
306 CmdArgs.push_back("-isysroot");
307 CmdArgs.push_back(A->getValue(Args));
308 }
309 }
310}
311
312/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targetting.
313//
314// FIXME: tblgen this.
315static const char *getARMTargetCPU(const ArgList &Args,
316 const llvm::Triple &Triple) {
317 // FIXME: Warn on inconsistent use of -mcpu and -march.
318
319 // If we have -mcpu=, use that.
320 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
321 return A->getValue(Args);
322
323 llvm::StringRef MArch;
324 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
325 // Otherwise, if we have -march= choose the base CPU for that arch.
326 MArch = A->getValue(Args);
327 } else {
328 // Otherwise, use the Arch from the triple.
329 MArch = Triple.getArchName();
330 }
331
332 if (MArch == "armv2" || MArch == "armv2a")
333 return "arm2";
334 if (MArch == "armv3")
335 return "arm6";
336 if (MArch == "armv3m")
337 return "arm7m";
338 if (MArch == "armv4" || MArch == "armv4t")
339 return "arm7tdmi";
340 if (MArch == "armv5" || MArch == "armv5t")
341 return "arm10tdmi";
342 if (MArch == "armv5e" || MArch == "armv5te")
343 return "arm1026ejs";
344 if (MArch == "armv5tej")
345 return "arm926ej-s";
346 if (MArch == "armv6" || MArch == "armv6k")
347 return "arm1136jf-s";
348 if (MArch == "armv6j")
349 return "arm1136j-s";
350 if (MArch == "armv6z" || MArch == "armv6zk")
351 return "arm1176jzf-s";
352 if (MArch == "armv6t2")
353 return "arm1156t2-s";
354 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
355 return "cortex-a8";
356 if (MArch == "armv7r" || MArch == "armv7-r")
357 return "cortex-r4";
358 if (MArch == "armv7m" || MArch == "armv7-m")
359 return "cortex-m3";
360 if (MArch == "ep9312")
361 return "ep9312";
362 if (MArch == "iwmmxt")
363 return "iwmmxt";
364 if (MArch == "xscale")
365 return "xscale";
366
367 // If all else failed, return the most base CPU LLVM supports.
368 return "arm7tdmi";
369}
370
371/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
372/// CPU.
373//
374// FIXME: This is redundant with -mcpu, why does LLVM use this.
375// FIXME: tblgen this, or kill it!
376static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) {
377 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" ||
378 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" ||
379 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" ||
380 CPU == "arm940t" || CPU == "ep9312")
381 return "v4t";
382
383 if (CPU == "arm10tdmi" || CPU == "arm1020t")
384 return "v5";
385
386 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" ||
387 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" ||
388 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" ||
389 CPU == "iwmmxt")
390 return "v5e";
391
392 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" ||
393 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore")
394 return "v6";
395
396 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s")
397 return "v6t2";
398
399 if (CPU == "cortex-a8" || CPU == "cortex-a9")
400 return "v7";
401
402 return "";
403}
404
405// FIXME: Move to target hook.
406static bool isSignedCharDefault(const llvm::Triple &Triple) {
407 switch (Triple.getArch()) {
408 default:
409 return true;
410
411 case llvm::Triple::ppc:
412 case llvm::Triple::ppc64:
413 if (Triple.getOS() == llvm::Triple::Darwin)
414 return true;
415 return false;
416
417 case llvm::Triple::systemz:
418 return false;
419 }
420}
421
422void Clang::AddARMTargetArgs(const ArgList &Args,
423 ArgStringList &CmdArgs) const {
424 const Driver &D = getToolChain().getDriver();
425 llvm::Triple Triple = getToolChain().getTriple();
426
427 // Select the ABI to use.
428 //
429 // FIXME: Support -meabi.
430 const char *ABIName = 0;
431 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
432 ABIName = A->getValue(Args);
433 } else {
434 // Select the default based on the platform.
435 switch(Triple.getEnvironment()) {
436 case llvm::Triple::GNUEABI:
437 ABIName = "aapcs-linux";
438 break;
439 case llvm::Triple::EABI:
440 ABIName = "aapcs";
441 break;
442 default:
443 ABIName = "apcs-gnu";
444 }
445 }
446 CmdArgs.push_back("-target-abi");
447 CmdArgs.push_back(ABIName);
448
449 // Set the CPU based on -march= and -mcpu=.
450 CmdArgs.push_back("-target-cpu");
451 CmdArgs.push_back(getARMTargetCPU(Args, Triple));
452
453 // Select the float ABI as determined by -msoft-float, -mhard-float, and
454 // -mfloat-abi=.
455 llvm::StringRef FloatABI;
456 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
457 options::OPT_mhard_float,
458 options::OPT_mfloat_abi_EQ)) {
459 if (A->getOption().matches(options::OPT_msoft_float))
460 FloatABI = "soft";
461 else if (A->getOption().matches(options::OPT_mhard_float))
462 FloatABI = "hard";
463 else {
464 FloatABI = A->getValue(Args);
465 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
466 D.Diag(clang::diag::err_drv_invalid_mfloat_abi)
467 << A->getAsString(Args);
468 FloatABI = "soft";
469 }
470 }
471 }
472
473 // If unspecified, choose the default based on the platform.
474 if (FloatABI.empty()) {
475 const llvm::Triple &Triple = getToolChain().getTriple();
476 switch (Triple.getOS()) {
477 case llvm::Triple::Darwin: {
478 // Darwin defaults to "softfp" for v6 and v7.
479 //
480 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
481 llvm::StringRef ArchName =
482 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
483 if (ArchName.startswith("v6") || ArchName.startswith("v7"))
484 FloatABI = "softfp";
485 else
486 FloatABI = "soft";
487 break;
488 }
489
490 case llvm::Triple::Linux: {
491 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) {
492 FloatABI = "softfp";
493 break;
494 }
495 }
496 // fall through
497
498 default:
499 switch(Triple.getEnvironment()) {
500 case llvm::Triple::GNUEABI:
501 FloatABI = "softfp";
502 break;
503 case llvm::Triple::EABI:
504 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
505 FloatABI = "softfp";
506 break;
507 default:
508 // Assume "soft", but warn the user we are guessing.
509 FloatABI = "soft";
510 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
511 break;
512 }
513 }
514 }
515
516 if (FloatABI == "soft") {
517 // Floating point operations and argument passing are soft.
518 //
519 // FIXME: This changes CPP defines, we need -target-soft-float.
520 CmdArgs.push_back("-msoft-float");
521 CmdArgs.push_back("-mfloat-abi");
522 CmdArgs.push_back("soft");
523 } else if (FloatABI == "softfp") {
524 // Floating point operations are hard, but argument passing is soft.
525 CmdArgs.push_back("-mfloat-abi");
526 CmdArgs.push_back("soft");
527 } else {
528 // Floating point operations and argument passing are hard.
529 assert(FloatABI == "hard" && "Invalid float abi!");
530 CmdArgs.push_back("-mfloat-abi");
531 CmdArgs.push_back("hard");
532 }
533
534 // Set appropriate target features for floating point mode.
535 //
536 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
537 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
538 // stripped out by the ARM target.
539
540 // Use software floating point operations?
541 if (FloatABI == "soft") {
542 CmdArgs.push_back("-target-feature");
543 CmdArgs.push_back("+soft-float");
544 }
545
546 // Use software floating point argument passing?
547 if (FloatABI != "hard") {
548 CmdArgs.push_back("-target-feature");
549 CmdArgs.push_back("+soft-float-abi");
550 }
551
552 // Honor -mfpu=.
553 //
554 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
555 // frontend target.
556 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
557 llvm::StringRef FPU = A->getValue(Args);
558
559 // Set the target features based on the FPU.
560 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
561 // Disable any default FPU support.
562 CmdArgs.push_back("-target-feature");
563 CmdArgs.push_back("-vfp2");
564 CmdArgs.push_back("-target-feature");
565 CmdArgs.push_back("-vfp3");
566 CmdArgs.push_back("-target-feature");
567 CmdArgs.push_back("-neon");
568 } else if (FPU == "vfp") {
569 CmdArgs.push_back("-target-feature");
570 CmdArgs.push_back("+vfp2");
571 } else if (FPU == "vfp3") {
572 CmdArgs.push_back("-target-feature");
573 CmdArgs.push_back("+vfp3");
574 } else if (FPU == "neon") {
575 CmdArgs.push_back("-target-feature");
576 CmdArgs.push_back("+neon");
577 } else
578 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
579 }
580}
581
582void Clang::AddMIPSTargetArgs(const ArgList &Args,
583 ArgStringList &CmdArgs) const {
584 const Driver &D = getToolChain().getDriver();
585
586 // Select the ABI to use.
587 const char *ABIName = 0;
588 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
589 ABIName = A->getValue(Args);
590 } else {
591 ABIName = "o32";
592 }
593
594 CmdArgs.push_back("-target-abi");
595 CmdArgs.push_back(ABIName);
596
597 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
598 llvm::StringRef MArch = A->getValue(Args);
599 CmdArgs.push_back("-target-cpu");
600
601 if ((MArch == "r2000") || (MArch == "r3000"))
602 CmdArgs.push_back("mips1");
603 else if (MArch == "r6000")
604 CmdArgs.push_back("mips2");
605 else
606 CmdArgs.push_back(MArch.str().c_str());
607 }
608
609 // Select the float ABI as determined by -msoft-float, -mhard-float, and
610 llvm::StringRef FloatABI;
611 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
612 options::OPT_mhard_float)) {
613 if (A->getOption().matches(options::OPT_msoft_float))
614 FloatABI = "soft";
615 else if (A->getOption().matches(options::OPT_mhard_float))
616 FloatABI = "hard";
617 }
618
619 // If unspecified, choose the default based on the platform.
620 if (FloatABI.empty()) {
621 // Assume "soft", but warn the user we are guessing.
622 FloatABI = "soft";
623 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
624 }
625
626 if (FloatABI == "soft") {
627 // Floating point operations and argument passing are soft.
628 //
629 // FIXME: This changes CPP defines, we need -target-soft-float.
630 CmdArgs.push_back("-msoft-float");
631 } else {
632 assert(FloatABI == "hard" && "Invalid float abi!");
633 CmdArgs.push_back("-mhard-float");
634 }
635}
636
637void Clang::AddSparcTargetArgs(const ArgList &Args,
638 ArgStringList &CmdArgs) const {
639 const Driver &D = getToolChain().getDriver();
640
641 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
642 llvm::StringRef MArch = A->getValue(Args);
643 CmdArgs.push_back("-target-cpu");
644 CmdArgs.push_back(MArch.str().c_str());
645 }
646
647 // Select the float ABI as determined by -msoft-float, -mhard-float, and
648 llvm::StringRef FloatABI;
649 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
650 options::OPT_mhard_float)) {
651 if (A->getOption().matches(options::OPT_msoft_float))
652 FloatABI = "soft";
653 else if (A->getOption().matches(options::OPT_mhard_float))
654 FloatABI = "hard";
655 }
656
657 // If unspecified, choose the default based on the platform.
658 if (FloatABI.empty()) {
659 switch (getToolChain().getTriple().getOS()) {
660 default:
661 // Assume "soft", but warn the user we are guessing.
662 FloatABI = "soft";
663 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft";
664 break;
665 }
666 }
667
668 if (FloatABI == "soft") {
669 // Floating point operations and argument passing are soft.
670 //
671 // FIXME: This changes CPP defines, we need -target-soft-float.
672 CmdArgs.push_back("-msoft-float");
673 CmdArgs.push_back("soft");
674 CmdArgs.push_back("-target-feature");
675 CmdArgs.push_back("+soft-float");
676 } else {
677 assert(FloatABI == "hard" && "Invalid float abi!");
678 CmdArgs.push_back("-mhard-float");
679 }
680}
681
682void Clang::AddX86TargetArgs(const ArgList &Args,
683 ArgStringList &CmdArgs) const {
684 if (!Args.hasFlag(options::OPT_mred_zone,
685 options::OPT_mno_red_zone,
686 true) ||
687 Args.hasArg(options::OPT_mkernel) ||
688 Args.hasArg(options::OPT_fapple_kext))
689 CmdArgs.push_back("-disable-red-zone");
690
691 if (Args.hasFlag(options::OPT_msoft_float,
692 options::OPT_mno_soft_float,
693 false))
694 CmdArgs.push_back("-no-implicit-float");
695
696 const char *CPUName = 0;
697 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
698 if (llvm::StringRef(A->getValue(Args)) == "native") {
699 // FIXME: Reject attempts to use -march=native unless the target matches
700 // the host.
701 //
702 // FIXME: We should also incorporate the detected target features for use
703 // with -native.
704 std::string CPU = llvm::sys::getHostCPUName();
705 if (!CPU.empty())
706 CPUName = Args.MakeArgString(CPU);
707 } else
708 CPUName = A->getValue(Args);
709 }
710
711 // Select the default CPU if none was given (or detection failed).
712 if (!CPUName) {
713 // FIXME: Need target hooks.
714 if (getToolChain().getOS().startswith("darwin")) {
715 if (getToolChain().getArchName() == "x86_64")
716 CPUName = "core2";
717 else if (getToolChain().getArchName() == "i386")
718 CPUName = "yonah";
719 } else if (getToolChain().getOS().startswith("haiku")) {
720 if (getToolChain().getArchName() == "x86_64")
721 CPUName = "x86-64";
722 else if (getToolChain().getArchName() == "i386")
723 CPUName = "i586";
724 } else if (getToolChain().getOS().startswith("openbsd")) {
725 if (getToolChain().getArchName() == "x86_64")
726 CPUName = "x86-64";
727 else if (getToolChain().getArchName() == "i386")
728 CPUName = "i486";
729 } else if (getToolChain().getOS().startswith("netbsd")) {
730 if (getToolChain().getArchName() == "x86_64")
731 CPUName = "x86-64";
732 else if (getToolChain().getArchName() == "i386")
733 CPUName = "i486";
734 } else if (getToolChain().getOS().startswith("freebsd")) {
735 if (getToolChain().getArchName() == "x86_64")
736 CPUName = "x86-64";
737 else if (getToolChain().getArchName() == "i386")
738 CPUName = "i486";
739 } else {
740 if (getToolChain().getArchName() == "x86_64")
741 CPUName = "x86-64";
742 else if (getToolChain().getArchName() == "i386")
743 CPUName = "pentium4";
744 }
745 }
746
747 if (CPUName) {
748 CmdArgs.push_back("-target-cpu");
749 CmdArgs.push_back(CPUName);
750 }
751
752 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
753 ie = Args.filtered_end(); it != ie; ++it) {
754 llvm::StringRef Name = (*it)->getOption().getName();
755 (*it)->claim();
756
757 // Skip over "-m".
758 assert(Name.startswith("-m") && "Invalid feature name.");
759 Name = Name.substr(2);
760
761 bool IsNegative = Name.startswith("no-");
762 if (IsNegative)
763 Name = Name.substr(3);
764
765 CmdArgs.push_back("-target-feature");
766 CmdArgs.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
767 }
768}
769
770static bool needsExceptions(const ArgList &Args, types::ID InputType,
771 const llvm::Triple &Triple) {
772 // Handle -fno-exceptions.
773 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
774 options::OPT_fno_exceptions)) {
775 if (A->getOption().matches(options::OPT_fexceptions))
776 return true;
777 else
778 return false;
779 }
780
781 // Otherwise, C++ inputs use exceptions.
782 if (types::isCXX(InputType))
783 return true;
784
785 // As do Objective-C non-fragile ABI inputs and all Objective-C inputs on
786 // x86_64 and ARM after SnowLeopard.
787 if (types::isObjC(InputType)) {
788 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi))
789 return true;
790 if (Triple.getOS() != llvm::Triple::Darwin)
791 return false;
792 return (Triple.getDarwinMajorNumber() >= 9 &&
793 (Triple.getArch() == llvm::Triple::x86_64 ||
794 Triple.getArch() == llvm::Triple::arm));
795 }
796
797 return false;
798}
799
800void Clang::ConstructJob(Compilation &C, const JobAction &JA,
801 const InputInfo &Output,
802 const InputInfoList &Inputs,
803 const ArgList &Args,
804 const char *LinkingOutput) const {
805 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
806 options::OPT_fapple_kext);
807 const Driver &D = getToolChain().getDriver();
808 ArgStringList CmdArgs;
809
810 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
811
812 // Invoke ourselves in -cc1 mode.
813 //
814 // FIXME: Implement custom jobs for internal actions.
815 CmdArgs.push_back("-cc1");
816
817 // Add the "effective" target triple.
818 CmdArgs.push_back("-triple");
819 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
820 CmdArgs.push_back(Args.MakeArgString(TripleStr));
821
822 // Select the appropriate action.
823 bool IsRewriter = false;
824 if (isa<AnalyzeJobAction>(JA)) {
825 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
826 CmdArgs.push_back("-analyze");
827 } else if (isa<PreprocessJobAction>(JA)) {
828 if (Output.getType() == types::TY_Dependencies)
829 CmdArgs.push_back("-Eonly");
830 else
831 CmdArgs.push_back("-E");
832 } else if (isa<AssembleJobAction>(JA)) {
833 CmdArgs.push_back("-emit-obj");
834
835 // At -O0, we use -mrelax-all by default.
836 bool IsOpt = false;
837 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
838 IsOpt = !A->getOption().matches(options::OPT_O0);
839 if (Args.hasFlag(options::OPT_mrelax_all,
840 options::OPT_mno_relax_all,
841 !IsOpt))
842 CmdArgs.push_back("-mrelax-all");
843
844 // When using an integrated assembler, translate -Wa, and -Xassembler
845 // options.
846 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
847 options::OPT_Xassembler),
848 ie = Args.filtered_end(); it != ie; ++it) {
849 const Arg *A = *it;
850 A->claim();
851
852 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
853 llvm::StringRef Value = A->getValue(Args, i);
854
855 if (Value == "-force_cpusubtype_ALL") {
856 // Do nothing, this is the default and we don't support anything else.
857 } else if (Value == "-L") {
858 // We don't support -L yet, but it isn't important enough to error
859 // on. No one should really be using it for a semantic change.
860 D.Diag(clang::diag::warn_drv_unsupported_option_argument)
861 << A->getOption().getName() << Value;
862 } else {
863 D.Diag(clang::diag::err_drv_unsupported_option_argument)
864 << A->getOption().getName() << Value;
865 }
866 }
867 }
868
869 // Also ignore explicit -force_cpusubtype_ALL option.
870 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
871 } else if (isa<PrecompileJobAction>(JA)) {
872 // Use PCH if the user requested it.
873 bool UsePCH = D.CCCUsePCH;
874
875 if (UsePCH)
876 CmdArgs.push_back("-emit-pch");
877 else
878 CmdArgs.push_back("-emit-pth");
879 } else {
880 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
881
882 if (JA.getType() == types::TY_Nothing) {
883 CmdArgs.push_back("-fsyntax-only");
884 } else if (JA.getType() == types::TY_LLVM_IR ||
885 JA.getType() == types::TY_LTO_IR) {
886 CmdArgs.push_back("-emit-llvm");
887 } else if (JA.getType() == types::TY_LLVM_BC ||
888 JA.getType() == types::TY_LTO_BC) {
889 CmdArgs.push_back("-emit-llvm-bc");
890 } else if (JA.getType() == types::TY_PP_Asm) {
891 CmdArgs.push_back("-S");
892 } else if (JA.getType() == types::TY_AST) {
893 CmdArgs.push_back("-emit-pch");
894 } else if (JA.getType() == types::TY_RewrittenObjC) {
895 CmdArgs.push_back("-rewrite-objc");
896 IsRewriter = true;
897 } else {
898 assert(JA.getType() == types::TY_PP_Asm &&
899 "Unexpected output type!");
900 }
901 }
902
903 // The make clang go fast button.
904 CmdArgs.push_back("-disable-free");
905
906 // Disable the verification pass in -asserts builds.
907#ifdef NDEBUG
908 CmdArgs.push_back("-disable-llvm-verifier");
909#endif
910
911 // Set the main file name, so that debug info works even with
912 // -save-temps.
913 CmdArgs.push_back("-main-file-name");
914 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
915
916 // Some flags which affect the language (via preprocessor
917 // defines). See darwin::CC1::AddCPPArgs.
918 if (Args.hasArg(options::OPT_static))
919 CmdArgs.push_back("-static-define");
920
921 if (isa<AnalyzeJobAction>(JA)) {
922 // Enable region store model by default.
923 CmdArgs.push_back("-analyzer-store=region");
924
925 // Treat blocks as analysis entry points.
926 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
927
928 // Add default argument set.
929 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
930 types::ID InputType = Inputs[0].getType();
931
932 // Checks to perform for all language types.
933
934 CmdArgs.push_back("-analyzer-checker=core");
935 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
936 CmdArgs.push_back("-analyzer-checker=unix");
937 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
938 CmdArgs.push_back("-analyzer-checker=macosx");
939
940 // Checks to perform for Objective-C/Objective-C++.
941 if (types::isObjC(InputType)) {
942 // Enable all checkers in 'cocoa' package.
943 CmdArgs.push_back("-analyzer-checker=cocoa");
944 }
945
946 // NOTE: Leaving -analyzer-check-objc-mem here is intentional.
947 // It also checks C code.
948 CmdArgs.push_back("-analyzer-check-objc-mem");
949
950 CmdArgs.push_back("-analyzer-eagerly-assume");
951 }
952
953 // Set the output format. The default is plist, for (lame) historical
954 // reasons.
955 CmdArgs.push_back("-analyzer-output");
956 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
957 CmdArgs.push_back(A->getValue(Args));
958 else
959 CmdArgs.push_back("plist");
960
961 // Disable the presentation of standard compiler warnings when
962 // using --analyze. We only want to show static analyzer diagnostics
963 // or frontend errors.
964 CmdArgs.push_back("-w");
965
966 // Add -Xanalyzer arguments when running as analyzer.
967 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
968 }
969
970 CheckCodeGenerationOptions(D, Args);
971
972 // Perform argument translation for LLVM backend. This
973 // takes some care in reconciling with llvm-gcc. The
974 // issue is that llvm-gcc translates these options based on
975 // the values in cc1, whereas we are processing based on
976 // the driver arguments.
977
978 // This comes from the default translation the driver + cc1
979 // would do to enable flag_pic.
980 //
981 // FIXME: Centralize this code.
982 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
983 Args.hasArg(options::OPT_fpic) ||
984 Args.hasArg(options::OPT_fPIE) ||
985 Args.hasArg(options::OPT_fpie));
986 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
987 Args.hasArg(options::OPT_static));
988 const char *Model = getToolChain().GetForcedPicModel();
989 if (!Model) {
990 if (Args.hasArg(options::OPT_mdynamic_no_pic))
991 Model = "dynamic-no-pic";
992 else if (PICDisabled)
993 Model = "static";
994 else if (PICEnabled)
995 Model = "pic";
996 else
997 Model = getToolChain().GetDefaultRelocationModel();
998 }
999 if (llvm::StringRef(Model) != "pic") {
1000 CmdArgs.push_back("-mrelocation-model");
1001 CmdArgs.push_back(Model);
1002 }
1003
1004 // Infer the __PIC__ value.
1005 //
1006 // FIXME: This isn't quite right on Darwin, which always sets
1007 // __PIC__=2.
1008 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
1009 CmdArgs.push_back("-pic-level");
1010 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
1011 }
1012 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1013 options::OPT_fno_merge_all_constants))
1014 CmdArgs.push_back("-no-merge-all-constants");
1015
1016 // LLVM Code Generator Options.
1017
1018 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1019 CmdArgs.push_back("-mregparm");
1020 CmdArgs.push_back(A->getValue(Args));
1021 }
1022
1023 // FIXME: Set --enable-unsafe-fp-math.
1024 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
1025 options::OPT_fomit_frame_pointer))
1026 CmdArgs.push_back("-mdisable-fp-elim");
1027 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1028 options::OPT_fno_zero_initialized_in_bss))
1029 CmdArgs.push_back("-mno-zero-initialized-in-bss");
1030 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1031 options::OPT_fno_strict_aliasing,
1032 getToolChain().IsStrictAliasingDefault()))
1033 CmdArgs.push_back("-relaxed-aliasing");
1034
1035 // Decide whether to use verbose asm. Verbose assembly is the default on
1036 // toolchains which have the integrated assembler on by default.
1037 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
1038 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
1039 IsVerboseAsmDefault) ||
1040 Args.hasArg(options::OPT_dA))
1041 CmdArgs.push_back("-masm-verbose");
1042
1043 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
1044 CmdArgs.push_back("-mdebug-pass");
1045 CmdArgs.push_back("Structure");
1046 }
1047 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
1048 CmdArgs.push_back("-mdebug-pass");
1049 CmdArgs.push_back("Arguments");
1050 }
1051
1052 // Enable -mconstructor-aliases except on darwin, where we have to
1053 // work around a linker bug; see <rdar://problem/7651567>.
1054 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin)
1055 CmdArgs.push_back("-mconstructor-aliases");
1056
1057 if (Args.hasArg(options::OPT_mms_bitfields)) {
1058 CmdArgs.push_back("-mms-bitfields");
1059 }
1060
1061 // This is a coarse approximation of what llvm-gcc actually does, both
1062 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
1063 // complicated ways.
1064 bool AsynchronousUnwindTables =
1065 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
1066 options::OPT_fno_asynchronous_unwind_tables,
1067 getToolChain().IsUnwindTablesDefault() &&
1068 !KernelOrKext);
1069 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
1070 AsynchronousUnwindTables))
1071 CmdArgs.push_back("-munwind-tables");
1072
1073 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
1074 CmdArgs.push_back("-mlimit-float-precision");
1075 CmdArgs.push_back(A->getValue(Args));
1076 }
1077
1078 // FIXME: Handle -mtune=.
1079 (void) Args.hasArg(options::OPT_mtune_EQ);
1080
1081 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
1082 CmdArgs.push_back("-mcode-model");
1083 CmdArgs.push_back(A->getValue(Args));
1084 }
1085
1086 // Add target specific cpu and features flags.
1087 switch(getToolChain().getTriple().getArch()) {
1088 default:
1089 break;
1090
1091 case llvm::Triple::arm:
1092 case llvm::Triple::thumb:
1093 AddARMTargetArgs(Args, CmdArgs);
1094 break;
1095
1096 case llvm::Triple::mips:
1097 case llvm::Triple::mipsel:
1098 AddMIPSTargetArgs(Args, CmdArgs);
1099 break;
1100
1101 case llvm::Triple::sparc:
1102 AddSparcTargetArgs(Args, CmdArgs);
1103 break;
1104
1105 case llvm::Triple::x86:
1106 case llvm::Triple::x86_64:
1107 AddX86TargetArgs(Args, CmdArgs);
1108 break;
1109 }
1110
1111 // Pass the linker version in use.
1112 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1113 CmdArgs.push_back("-target-linker-version");
1114 CmdArgs.push_back(A->getValue(Args));
1115 }
1116
1117 // -mno-omit-leaf-frame-pointer is the default on Darwin.
1118 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
1119 options::OPT_mno_omit_leaf_frame_pointer,
1120 getToolChain().getTriple().getOS() != llvm::Triple::Darwin))
1121 CmdArgs.push_back("-momit-leaf-frame-pointer");
1122
1123 // -fno-math-errno is default.
1124 if (Args.hasFlag(options::OPT_fmath_errno,
1125 options::OPT_fno_math_errno,
1126 false))
1127 CmdArgs.push_back("-fmath-errno");
1128
1129 // Explicitly error on some things we know we don't support and can't just
1130 // ignore.
1131 types::ID InputType = Inputs[0].getType();
1132 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1133 Arg *Unsupported;
1134 if ((Unsupported = Args.getLastArg(options::OPT_MG)) ||
1135 (Unsupported = Args.getLastArg(options::OPT_iframework)))
1136 D.Diag(clang::diag::err_drv_clang_unsupported)
1137 << Unsupported->getOption().getName();
1138
1139 if (types::isCXX(InputType) &&
1140 getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1141 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1142 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)))
1143 D.Diag(clang::diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1144 << Unsupported->getOption().getName();
1145 }
1146 }
1147
1148 Args.AddAllArgs(CmdArgs, options::OPT_v);
1149 Args.AddLastArg(CmdArgs, options::OPT_H);
1150 if (D.CCPrintHeaders) {
1151 CmdArgs.push_back("-header-include-file");
1152 CmdArgs.push_back(D.CCPrintHeadersFilename ?
1153 D.CCPrintHeadersFilename : "-");
1154 }
1155 Args.AddLastArg(CmdArgs, options::OPT_P);
1156 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
1157
1158 // Special case debug options to only pass -g to clang. This is
1159 // wrong.
1160 Args.ClaimAllArgs(options::OPT_g_Group);
1161 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
1162 if (!A->getOption().matches(options::OPT_g0))
1163 CmdArgs.push_back("-g");
1164
1165 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1166 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1167
1168 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
1169
1170 Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
1171 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
1172 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
1173
1174 // Pass the path to compiler resource files.
1175 CmdArgs.push_back("-resource-dir");
1176 CmdArgs.push_back(D.ResourceDir.c_str());
1177
1178 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
1179
1180 // Add preprocessing options like -I, -D, etc. if we are using the
1181 // preprocessor.
1182 //
1183 // FIXME: Support -fpreprocessed
1184 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
1185 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
1186
1187 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
1188 // others.
1189 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1190 if (A->getOption().matches(options::OPT_O4))
1191 CmdArgs.push_back("-O3");
1192 else if (A->getOption().matches(options::OPT_O) &&
1193 A->getValue(Args)[0] == '\0')
1194 CmdArgs.push_back("-O2");
1195 else if (A->getOption().matches(options::OPT_O) &&
1196 A->getValue(Args)[0] == 'z' &&
1197 A->getValue(Args)[1] == '\0')
1198 CmdArgs.push_back("-Os");
1199 else
1200 A->render(Args, CmdArgs);
1201 }
1202
1203 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
1204 Args.AddLastArg(CmdArgs, options::OPT_pedantic);
1205 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
1206 Args.AddLastArg(CmdArgs, options::OPT_w);
1207
1208 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
1209 // (-ansi is equivalent to -std=c89).
1210 //
1211 // If a std is supplied, only add -trigraphs if it follows the
1212 // option.
1213 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1214 if (Std->getOption().matches(options::OPT_ansi))
1215 if (types::isCXX(InputType))
1216 CmdArgs.push_back("-std=c++98");
1217 else
1218 CmdArgs.push_back("-std=c89");
1219 else
1220 Std->render(Args, CmdArgs);
1221
1222 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
1223 options::OPT_trigraphs))
1224 if (A != Std)
1225 A->render(Args, CmdArgs);
1226 } else {
1227 // Honor -std-default.
1228 //
1229 // FIXME: Clang doesn't correctly handle -std= when the input language
1230 // doesn't match. For the time being just ignore this for C++ inputs;
1231 // eventually we want to do all the standard defaulting here instead of
1232 // splitting it between the driver and clang -cc1.
1233 if (!types::isCXX(InputType))
1234 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1235 "-std=", /*Joined=*/true);
1236 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
1237 }
1238
1239 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
1240 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
1241 if (Asm->getOption().matches(options::OPT_fasm))
1242 CmdArgs.push_back("-fgnu-keywords");
1243 else
1244 CmdArgs.push_back("-fno-gnu-keywords");
1245 }
1246
1247 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
1248 CmdArgs.push_back("-ftemplate-depth");
1249 CmdArgs.push_back(A->getValue(Args));
1250 }
1251
1252 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
1253 options::OPT_Wlarge_by_value_copy_def)) {
1254 CmdArgs.push_back("-Wlarge-by-value-copy");
1255 if (A->getNumValues())
1256 CmdArgs.push_back(A->getValue(Args));
1257 else
1258 CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy.
1259 }
1260
1261 if (Args.hasArg(options::OPT__relocatable_pch))
1262 CmdArgs.push_back("-relocatable-pch");
1263
1264 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
1265 CmdArgs.push_back("-fconstant-string-class");
1266 CmdArgs.push_back(A->getValue(Args));
1267 }
1268
1269 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
1270 CmdArgs.push_back("-ftabstop");
1271 CmdArgs.push_back(A->getValue(Args));
1272 }
1273
1274 CmdArgs.push_back("-ferror-limit");
1275 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
1276 CmdArgs.push_back(A->getValue(Args));
1277 else
1278 CmdArgs.push_back("19");
1279
1280 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
1281 CmdArgs.push_back("-fmacro-backtrace-limit");
1282 CmdArgs.push_back(A->getValue(Args));
1283 }
1284
1285 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
1286 CmdArgs.push_back("-ftemplate-backtrace-limit");
1287 CmdArgs.push_back(A->getValue(Args));
1288 }
1289
1290 // Pass -fmessage-length=.
1291 CmdArgs.push_back("-fmessage-length");
1292 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
1293 CmdArgs.push_back(A->getValue(Args));
1294 } else {
1295 // If -fmessage-length=N was not specified, determine whether this is a
1296 // terminal and, if so, implicitly define -fmessage-length appropriately.
1297 unsigned N = llvm::sys::Process::StandardErrColumns();
1298 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N)));
1299 }
1300
1301 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
1302 CmdArgs.push_back("-fvisibility");
1303 CmdArgs.push_back(A->getValue(Args));
1304 }
1305
1306 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
1307
1308 // -fhosted is default.
1309 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
1310 options::OPT_fhosted,
1311 false))
1312 CmdArgs.push_back("-ffreestanding");
1313
1314 // Forward -f (flag) options which we can pass directly.
1315 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
1316 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
1317 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
1318 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
1319 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
1320 Args.AddLastArg(CmdArgs, options::OPT_pg);
1321
1322 // -flax-vector-conversions is default.
1323 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
1324 options::OPT_fno_lax_vector_conversions))
1325 CmdArgs.push_back("-fno-lax-vector-conversions");
1326
1327 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
1328 // takes precedence.
1329 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
1330 if (!GCArg)
1331 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
1332 if (GCArg) {
1333 if (getToolChain().SupportsObjCGC()) {
1334 GCArg->render(Args, CmdArgs);
1335 } else {
1336 // FIXME: We should move this to a hard error.
1337 D.Diag(clang::diag::warn_drv_objc_gc_unsupported)
1338 << GCArg->getAsString(Args);
1339 }
1340 }
1341
1342 if (Args.getLastArg(options::OPT_fapple_kext))
1343 CmdArgs.push_back("-fapple-kext");
1344
1345 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column);
1346 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
1347 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
1348 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
1349 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
1350 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
1351
1352 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
1353 CmdArgs.push_back("-ftrapv-handler");
1354 CmdArgs.push_back(A->getValue(Args));
1355 }
1356
1357 Args.AddLastArg(CmdArgs, options::OPT_fwrapv);
1358 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
1359 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
1360
1361 Args.AddLastArg(CmdArgs, options::OPT_pthread);
1362
1363 // -stack-protector=0 is default.
1364 unsigned StackProtectorLevel = 0;
1365 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
1366 options::OPT_fstack_protector_all,
1367 options::OPT_fstack_protector)) {
1368 if (A->getOption().matches(options::OPT_fstack_protector))
1369 StackProtectorLevel = 1;
1370 else if (A->getOption().matches(options::OPT_fstack_protector_all))
1371 StackProtectorLevel = 2;
1372 } else
1373 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel();
1374 if (StackProtectorLevel) {
1375 CmdArgs.push_back("-stack-protector");
1376 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel)));
1377 }
1378
1379 // Forward -f options with positive and negative forms; we translate
1380 // these by hand.
1381
1382 if (Args.hasArg(options::OPT_mkernel)) {
1383 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
1384 CmdArgs.push_back("-fapple-kext");
1385 if (!Args.hasArg(options::OPT_fbuiltin))
1386 CmdArgs.push_back("-fno-builtin");
1387 }
1388 // -fbuiltin is default.
1389 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
1390 CmdArgs.push_back("-fno-builtin");
1391
1392 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1393 options::OPT_fno_assume_sane_operator_new))
1394 CmdArgs.push_back("-fno-assume-sane-operator-new");
1395
1396 // -fblocks=0 is default.
1397 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
1398 getToolChain().IsBlocksDefault())) {
1399 CmdArgs.push_back("-fblocks");
1400 }
1401
1402 // -faccess-control is default.
1403 if (Args.hasFlag(options::OPT_fno_access_control,
1404 options::OPT_faccess_control,
1405 false))
1406 CmdArgs.push_back("-fno-access-control");
1407
1408 // -felide-constructors is the default.
1409 if (Args.hasFlag(options::OPT_fno_elide_constructors,
1410 options::OPT_felide_constructors,
1411 false))
1412 CmdArgs.push_back("-fno-elide-constructors");
1413
1414 // -fexceptions=0 is default.
1415 if (!KernelOrKext &&
1416 needsExceptions(Args, InputType, getToolChain().getTriple()))
1417 CmdArgs.push_back("-fexceptions");
1418
1419 if (getToolChain().UseSjLjExceptions())
1420 CmdArgs.push_back("-fsjlj-exceptions");
1421
1422 // -frtti is default.
1423 if (KernelOrKext ||
1424 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
1425 CmdArgs.push_back("-fno-rtti");
1426
1427 // -fshort-enums=0 is default.
1428 // FIXME: Are there targers where -fshort-enums is on by default ?
1429 if (Args.hasFlag(options::OPT_fshort_enums,
1430 options::OPT_fno_short_enums, false))
1431 CmdArgs.push_back("-fshort-enums");
1432
1433 // -fsigned-char is default.
1434 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
1435 isSignedCharDefault(getToolChain().getTriple())))
1436 CmdArgs.push_back("-fno-signed-char");
1437
1438 // -fthreadsafe-static is default.
1439 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
1440 options::OPT_fno_threadsafe_statics))
1441 CmdArgs.push_back("-fno-threadsafe-statics");
1442
1443 // -fuse-cxa-atexit is default.
1444 if (KernelOrKext ||
1445 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
1446 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
1447 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
1448 CmdArgs.push_back("-fno-use-cxa-atexit");
1449
1450 // -fms-extensions=0 is default.
1451 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1452 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1453 CmdArgs.push_back("-fms-extensions");
1454
1455 // -fmsc-version=1300 is default.
1456 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1457 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
1458 Args.hasArg(options::OPT_fmsc_version)) {
1459 llvm::StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
1460 if (msc_ver.empty())
1461 CmdArgs.push_back("-fmsc-version=1300");
1462 else
1463 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
1464 }
1465
1466
1467 // -fborland-extensions=0 is default.
1468 if (Args.hasFlag(options::OPT_fborland_extensions,
1469 options::OPT_fno_borland_extensions, false))
1470 CmdArgs.push_back("-fborland-extensions");
1471
1472 // -fgnu-keywords default varies depending on language; only pass if
1473 // specified.
1474 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
1475 options::OPT_fno_gnu_keywords))
1476 A->render(Args, CmdArgs);
1477
1478 // -fnext-runtime defaults to on Darwin and when rewriting Objective-C, and is
1479 // -the -cc1 default.
1480 bool NeXTRuntimeIsDefault =
1481 IsRewriter || getToolChain().getTriple().getOS() == llvm::Triple::Darwin;
1482 if (!Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
1483 NeXTRuntimeIsDefault))
1484 CmdArgs.push_back("-fgnu-runtime");
1485
1486 // -fobjc-nonfragile-abi=0 is default.
1487 if (types::isObjC(InputType)) {
1488 // Compute the Objective-C ABI "version" to use. Version numbers are
1489 // slightly confusing for historical reasons:
1490 // 1 - Traditional "fragile" ABI
1491 // 2 - Non-fragile ABI, version 1
1492 // 3 - Non-fragile ABI, version 2
1493 unsigned Version = 1;
1494 // If -fobjc-abi-version= is present, use that to set the version.
1495 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
1496 if (llvm::StringRef(A->getValue(Args)) == "1")
1497 Version = 1;
1498 else if (llvm::StringRef(A->getValue(Args)) == "2")
1499 Version = 2;
1500 else if (llvm::StringRef(A->getValue(Args)) == "3")
1501 Version = 3;
1502 else
1503 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
1504 } else {
1505 // Otherwise, determine if we are using the non-fragile ABI.
1506 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
1507 options::OPT_fno_objc_nonfragile_abi,
1508 getToolChain().IsObjCNonFragileABIDefault())) {
1509 // Determine the non-fragile ABI version to use.
1510#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
1511 unsigned NonFragileABIVersion = 1;
1512#else
1513 unsigned NonFragileABIVersion = 2;
1514#endif
1515
1516 if (Arg *A = Args.getLastArg(
1517 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
1518 if (llvm::StringRef(A->getValue(Args)) == "1")
1519 NonFragileABIVersion = 1;
1520 else if (llvm::StringRef(A->getValue(Args)) == "2")
1521 NonFragileABIVersion = 2;
1522 else
1523 D.Diag(clang::diag::err_drv_clang_unsupported)
1524 << A->getAsString(Args);
1525 }
1526
1527 Version = 1 + NonFragileABIVersion;
1528 } else {
1529 Version = 1;
1530 }
1531 }
1532
1533 if (Version == 2 || Version == 3) {
1534 CmdArgs.push_back("-fobjc-nonfragile-abi");
1535
1536 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
1537 // legacy is the default.
1538 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
1539 options::OPT_fno_objc_legacy_dispatch,
1540 getToolChain().IsObjCLegacyDispatchDefault())) {
1541 if (getToolChain().UseObjCMixedDispatch())
1542 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
1543 else
1544 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
1545 }
1546 }
1547
1548 // -fobjc-default-synthesize-properties=0 is default.
1549 if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties,
1550 options::OPT_fno_objc_default_synthesize_properties,
1551 getToolChain().IsObjCDefaultSynthPropertiesDefault())) {
1552 CmdArgs.push_back("-fobjc-default-synthesize-properties");
1553 }
1554
1555 // -fobjc-exceptions is default.
1556 if (!Args.hasFlag(options::OPT_fobjc_exceptions,
1557 options::OPT_fno_objc_exceptions))
1558 CmdArgs.push_back("-fno-objc-exceptions");
1559 }
1560
1561 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1562 options::OPT_fno_assume_sane_operator_new))
1563 CmdArgs.push_back("-fno-assume-sane-operator-new");
1564
1565 // -fconstant-cfstrings is default, and may be subject to argument translation
1566 // on Darwin.
1567 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
1568 options::OPT_fno_constant_cfstrings) ||
1569 !Args.hasFlag(options::OPT_mconstant_cfstrings,
1570 options::OPT_mno_constant_cfstrings))
1571 CmdArgs.push_back("-fno-constant-cfstrings");
1572
1573 // -fshort-wchar default varies depending on platform; only
1574 // pass if specified.
1575 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
1576 A->render(Args, CmdArgs);
1577
1578 // -fno-pascal-strings is default, only pass non-default. If the tool chain
1579 // happened to translate to -mpascal-strings, we want to back translate here.
1580 //
1581 // FIXME: This is gross; that translation should be pulled from the
1582 // tool chain.
1583 if (Args.hasFlag(options::OPT_fpascal_strings,
1584 options::OPT_fno_pascal_strings,
1585 false) ||
1586 Args.hasFlag(options::OPT_mpascal_strings,
1587 options::OPT_mno_pascal_strings,
1588 false))
1589 CmdArgs.push_back("-fpascal-strings");
1590
1591 if (Args.hasArg(options::OPT_mkernel) ||
1592 Args.hasArg(options::OPT_fapple_kext)) {
1593 if (!Args.hasArg(options::OPT_fcommon))
1594 CmdArgs.push_back("-fno-common");
1595 }
1596 // -fcommon is default, only pass non-default.
1597 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
1598 CmdArgs.push_back("-fno-common");
1599
1600 // -fsigned-bitfields is default, and clang doesn't yet support
1601 // -funsigned-bitfields.
1602 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
1603 options::OPT_funsigned_bitfields))
1604 D.Diag(clang::diag::warn_drv_clang_unsupported)
1605 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
1606
1607 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
1608 if (!Args.hasFlag(options::OPT_ffor_scope,
1609 options::OPT_fno_for_scope))
1610 D.Diag(clang::diag::err_drv_clang_unsupported)
1611 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
1612
1613 // -fcaret-diagnostics is default.
1614 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
1615 options::OPT_fno_caret_diagnostics, true))
1616 CmdArgs.push_back("-fno-caret-diagnostics");
1617
1618 // -fdiagnostics-fixit-info is default, only pass non-default.
1619 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
1620 options::OPT_fno_diagnostics_fixit_info))
1621 CmdArgs.push_back("-fno-diagnostics-fixit-info");
1622
1623 // Enable -fdiagnostics-show-option by default.
1624 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
1625 options::OPT_fno_diagnostics_show_option))
1626 CmdArgs.push_back("-fdiagnostics-show-option");
1627
1628 if (const Arg *A =
1629 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
1630 CmdArgs.push_back("-fdiagnostics-show-category");
1631 CmdArgs.push_back(A->getValue(Args));
1632 }
1633
1634 // Color diagnostics are the default, unless the terminal doesn't support
1635 // them.
1636 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
1637 options::OPT_fno_color_diagnostics,
1638 llvm::sys::Process::StandardErrHasColors()))
1639 CmdArgs.push_back("-fcolor-diagnostics");
1640
1641 if (!Args.hasFlag(options::OPT_fshow_source_location,
1642 options::OPT_fno_show_source_location))
1643 CmdArgs.push_back("-fno-show-source-location");
1644
1645 if (!Args.hasFlag(options::OPT_fspell_checking,
1646 options::OPT_fno_spell_checking))
1647 CmdArgs.push_back("-fno-spell-checking");
1648
1649
1650 // Silently ignore -fasm-blocks for now.
1651 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
1652 false);
1653
1654 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
1655 A->render(Args, CmdArgs);
1656
1657 // -fdollars-in-identifiers default varies depending on platform and
1658 // language; only pass if specified.
1659 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
1660 options::OPT_fno_dollars_in_identifiers)) {
1661 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
1662 CmdArgs.push_back("-fdollars-in-identifiers");
1663 else
1664 CmdArgs.push_back("-fno-dollars-in-identifiers");
1665 }
1666
1667 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
1668 // practical purposes.
1669 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
1670 options::OPT_fno_unit_at_a_time)) {
1671 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
1672 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args);
1673 }
1674
1675 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
1676 //
1677 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
1678#if 0
1679 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
1680 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
1681 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
1682 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
1683 CmdArgs.push_back("-fno-builtin-strcat");
1684 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
1685 CmdArgs.push_back("-fno-builtin-strcpy");
1686 }
1687#endif
1688
1689 if (Arg *A = Args.getLastArg(options::OPT_traditional,
1690 options::OPT_traditional_cpp))
1691 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
1692
1693 Args.AddLastArg(CmdArgs, options::OPT_dM);
1694 Args.AddLastArg(CmdArgs, options::OPT_dD);
1695
1696 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
1697 // parser.
1698 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
1699 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
1700 ie = Args.filtered_end(); it != ie; ++it) {
1701 (*it)->claim();
1702
1703 // We translate this by hand to the -cc1 argument, since nightly test uses
1704 // it and developers have been trained to spell it with -mllvm.
1705 if (llvm::StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
1706 CmdArgs.push_back("-disable-llvm-optzns");
1707 else
1708 (*it)->render(Args, CmdArgs);
1709 }
1710
1711 if (Output.getType() == types::TY_Dependencies) {
1712 // Handled with other dependency code.
1713 } else if (Output.isFilename()) {
1714 CmdArgs.push_back("-o");
1715 CmdArgs.push_back(Output.getFilename());
1716 } else {
1717 assert(Output.isNothing() && "Invalid output.");
1718 }
1719
1720 for (InputInfoList::const_iterator
1721 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1722 const InputInfo &II = *it;
1723 CmdArgs.push_back("-x");
1724 CmdArgs.push_back(types::getTypeName(II.getType()));
1725 if (II.isFilename())
1726 CmdArgs.push_back(II.getFilename());
1727 else
1728 II.getInputArg().renderAsInput(Args, CmdArgs);
1729 }
1730
1731 Args.AddAllArgs(CmdArgs, options::OPT_undef);
1732
1733 const char *Exec = getToolChain().getDriver().getClangProgramPath();
1734
1735 // Optionally embed the -cc1 level arguments into the debug info, for build
1736 // analysis.
1737 if (getToolChain().UseDwarfDebugFlags()) {
1738 ArgStringList OriginalArgs;
1739 for (ArgList::const_iterator it = Args.begin(),
1740 ie = Args.end(); it != ie; ++it)
1741 (*it)->render(Args, OriginalArgs);
1742
1743 llvm::SmallString<256> Flags;
1744 Flags += Exec;
1745 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
1746 Flags += " ";
1747 Flags += OriginalArgs[i];
1748 }
1749 CmdArgs.push_back("-dwarf-debug-flags");
1750 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
1751 }
1752
1753 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
1754
1755 if (Arg *A = Args.getLastArg(options::OPT_pg))
1756 if (Args.hasArg(options::OPT_fomit_frame_pointer))
1757 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
1758 << "-fomit-frame-pointer" << A->getAsString(Args);
1759
1760 // Claim some arguments which clang supports automatically.
1761
1762 // -fpch-preprocess is used with gcc to add a special marker in the output to
1763 // include the PCH file. Clang's PTH solution is completely transparent, so we
1764 // do not need to deal with it at all.
1765 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
1766
1767 // Claim some arguments which clang doesn't support, but we don't
1768 // care to warn the user about.
1769 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
1770 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
1771}
1772
1773void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
1774 const InputInfo &Output,
1775 const InputInfoList &Inputs,
1776 const ArgList &Args,
1777 const char *LinkingOutput) const {
1778 ArgStringList CmdArgs;
1779
1780 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
1781 const InputInfo &Input = Inputs[0];
1782
1783 // Don't warn about "clang -w -c foo.s"
1784 Args.ClaimAllArgs(options::OPT_w);
1785
1786 // Invoke ourselves in -cc1as mode.
1787 //
1788 // FIXME: Implement custom jobs for internal actions.
1789 CmdArgs.push_back("-cc1as");
1790
1791 // Add the "effective" target triple.
1792 CmdArgs.push_back("-triple");
1793 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1794 CmdArgs.push_back(Args.MakeArgString(TripleStr));
1795
1796 // Set the output mode, we currently only expect to be used as a real
1797 // assembler.
1798 CmdArgs.push_back("-filetype");
1799 CmdArgs.push_back("obj");
1800
1801 // At -O0, we use -mrelax-all by default.
1802 bool IsOpt = false;
1803 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1804 IsOpt = !A->getOption().matches(options::OPT_O0);
1805 if (Args.hasFlag(options::OPT_mrelax_all,
1806 options::OPT_mno_relax_all,
1807 !IsOpt))
1808 CmdArgs.push_back("-relax-all");
1809
1810 // FIXME: Add -force_cpusubtype_ALL support, once we have it.
1811
1812 // FIXME: Add -g support, once we have it.
1813
1814 // FIXME: Add -static support, once we have it.
1815
1816 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
1817 options::OPT_Xassembler);
1818
1819 assert(Output.isFilename() && "Unexpected lipo output.");
1820 CmdArgs.push_back("-o");
1821 CmdArgs.push_back(Output.getFilename());
1822
1823 assert(Input.isFilename() && "Invalid input.");
1824 CmdArgs.push_back(Input.getFilename());
1825
1826 const char *Exec = getToolChain().getDriver().getClangProgramPath();
1827 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
1828}
1829
1830void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
1831 const InputInfo &Output,
1832 const InputInfoList &Inputs,
1833 const ArgList &Args,
1834 const char *LinkingOutput) const {
1835 const Driver &D = getToolChain().getDriver();
1836 ArgStringList CmdArgs;
1837
1838 for (ArgList::const_iterator
1839 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
1840 Arg *A = *it;
1841 if (A->getOption().hasForwardToGCC()) {
1842 // Don't forward any -g arguments to assembly steps.
1843 if (isa<AssembleJobAction>(JA) &&
1844 A->getOption().matches(options::OPT_g_Group))
1845 continue;
1846
1847 // It is unfortunate that we have to claim here, as this means
1848 // we will basically never report anything interesting for
1849 // platforms using a generic gcc, even if we are just using gcc
1850 // to get to the assembler.
1851 A->claim();
1852 A->render(Args, CmdArgs);
1853 }
1854 }
1855
1856 RenderExtraToolArgs(JA, CmdArgs);
1857
1858 // If using a driver driver, force the arch.
1859 const std::string &Arch = getToolChain().getArchName();
1860 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) {
1861 CmdArgs.push_back("-arch");
1862
1863 // FIXME: Remove these special cases.
1864 if (Arch == "powerpc")
1865 CmdArgs.push_back("ppc");
1866 else if (Arch == "powerpc64")
1867 CmdArgs.push_back("ppc64");
1868 else
1869 CmdArgs.push_back(Args.MakeArgString(Arch));
1870 }
1871
1872 // Try to force gcc to match the tool chain we want, if we recognize
1873 // the arch.
1874 //
1875 // FIXME: The triple class should directly provide the information we want
1876 // here.
1877 if (Arch == "i386" || Arch == "powerpc")
1878 CmdArgs.push_back("-m32");
1879 else if (Arch == "x86_64" || Arch == "powerpc64")
1880 CmdArgs.push_back("-m64");
1881
1882 if (Output.isFilename()) {
1883 CmdArgs.push_back("-o");
1884 CmdArgs.push_back(Output.getFilename());
1885 } else {
1886 assert(Output.isNothing() && "Unexpected output");
1887 CmdArgs.push_back("-fsyntax-only");
1888 }
1889
1890
1891 // Only pass -x if gcc will understand it; otherwise hope gcc
1892 // understands the suffix correctly. The main use case this would go
1893 // wrong in is for linker inputs if they happened to have an odd
1894 // suffix; really the only way to get this to happen is a command
1895 // like '-x foobar a.c' which will treat a.c like a linker input.
1896 //
1897 // FIXME: For the linker case specifically, can we safely convert
1898 // inputs into '-Wl,' options?
1899 for (InputInfoList::const_iterator
1900 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1901 const InputInfo &II = *it;
1902
1903 // Don't try to pass LLVM or AST inputs to a generic gcc.
1904 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
1905 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
1906 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
1907 << getToolChain().getTripleString();
1908 else if (II.getType() == types::TY_AST)
1909 D.Diag(clang::diag::err_drv_no_ast_support)
1910 << getToolChain().getTripleString();
1911
1912 if (types::canTypeBeUserSpecified(II.getType())) {
1913 CmdArgs.push_back("-x");
1914 CmdArgs.push_back(types::getTypeName(II.getType()));
1915 }
1916
1917 if (II.isFilename())
1918 CmdArgs.push_back(II.getFilename());
1919 else {
1920 const Arg &A = II.getInputArg();
1921
1922 // Reverse translate some rewritten options.
1923 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
1924 CmdArgs.push_back("-lstdc++");
1925 continue;
1926 }
1927
1928 // Don't render as input, we need gcc to do the translations.
1929 A.render(Args, CmdArgs);
1930 }
1931 }
1932
1933 const char *GCCName = getToolChain().getDriver().getCCCGenericGCCName().c_str();
1934 const char *Exec =
1935 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
1936 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
1937}
1938
1939void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
1940 ArgStringList &CmdArgs) const {
1941 CmdArgs.push_back("-E");
1942}
1943
1944void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
1945 ArgStringList &CmdArgs) const {
1946 // The type is good enough.
1947}
1948
1949void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
1950 ArgStringList &CmdArgs) const {
1951 const Driver &D = getToolChain().getDriver();
1952
1953 // If -flto, etc. are present then make sure not to force assembly output.
1954 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
1955 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
1956 CmdArgs.push_back("-c");
1957 else {
1958 if (JA.getType() != types::TY_PP_Asm)
1959 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
1960 << getTypeName(JA.getType());
1961
1962 CmdArgs.push_back("-S");
1963 }
1964}
1965
1966void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
1967 ArgStringList &CmdArgs) const {
1968 CmdArgs.push_back("-c");
1969}
1970
1971void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
1972 ArgStringList &CmdArgs) const {
1973 // The types are (hopefully) good enough.
1974}
1975
1976const char *darwin::CC1::getCC1Name(types::ID Type) const {
1977 switch (Type) {
1978 default:
1979 assert(0 && "Unexpected type for Darwin CC1 tool.");
1980 case types::TY_Asm:
1981 case types::TY_C: case types::TY_CHeader:
1982 case types::TY_PP_C: case types::TY_PP_CHeader:
1983 return "cc1";
1984 case types::TY_ObjC: case types::TY_ObjCHeader:
1985 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader:
1986 return "cc1obj";
1987 case types::TY_CXX: case types::TY_CXXHeader:
1988 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
1989 return "cc1plus";
1990 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
1991 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader:
1992 return "cc1objplus";
1993 }
1994}
1995
1996const char *darwin::CC1::getBaseInputName(const ArgList &Args,
1997 const InputInfoList &Inputs) {
1998 return Args.MakeArgString(
1999 llvm::sys::path::filename(Inputs[0].getBaseInput()));
2000}
2001
2002const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
2003 const InputInfoList &Inputs) {
2004 const char *Str = getBaseInputName(Args, Inputs);
2005
2006 if (const char *End = strrchr(Str, '.'))
2007 return Args.MakeArgString(std::string(Str, End));
2008
2009 return Str;
2010}
2011
2012const char *
2013darwin::CC1::getDependencyFileName(const ArgList &Args,
2014 const InputInfoList &Inputs) {
2015 // FIXME: Think about this more.
2016 std::string Res;
2017
2018 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2019 std::string Str(OutputOpt->getValue(Args));
2020
2021 Res = Str.substr(0, Str.rfind('.'));
2022 } else
2023 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
2024
2025 return Args.MakeArgString(Res + ".d");
2026}
2027
2028void darwin::CC1::AddCC1Args(const ArgList &Args,
2029 ArgStringList &CmdArgs) const {
2030 const Driver &D = getToolChain().getDriver();
2031
2032 CheckCodeGenerationOptions(D, Args);
2033
2034 // Derived from cc1 spec.
2035 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
2036 !Args.hasArg(options::OPT_mdynamic_no_pic))
2037 CmdArgs.push_back("-fPIC");
2038
2039 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2040 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2041 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2042 CmdArgs.push_back("-fno-builtin-strcat");
2043 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2044 CmdArgs.push_back("-fno-builtin-strcpy");
2045 }
2046
2047 // gcc has some code here to deal with when no -mmacosx-version-min
2048 // and no -miphoneos-version-min is present, but this never happens
2049 // due to tool chain specific argument translation.
2050
2051 if (Args.hasArg(options::OPT_g_Flag) &&
2052 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
2053 CmdArgs.push_back("-feliminate-unused-debug-symbols");
2054}
2055
2056void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2057 const InputInfoList &Inputs,
2058 const ArgStringList &OutputArgs) const {
2059 const Driver &D = getToolChain().getDriver();
2060
2061 // Derived from cc1_options spec.
2062 if (Args.hasArg(options::OPT_fast) ||
2063 Args.hasArg(options::OPT_fastf) ||
2064 Args.hasArg(options::OPT_fastcp))
2065 CmdArgs.push_back("-O3");
2066
2067 if (Arg *A = Args.getLastArg(options::OPT_pg))
2068 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2069 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2070 << A->getAsString(Args) << "-fomit-frame-pointer";
2071
2072 AddCC1Args(Args, CmdArgs);
2073
2074 if (!Args.hasArg(options::OPT_Q))
2075 CmdArgs.push_back("-quiet");
2076
2077 CmdArgs.push_back("-dumpbase");
2078 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
2079
2080 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2081
2082 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2083 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
2084
2085 // FIXME: The goal is to use the user provided -o if that is our
2086 // final output, otherwise to drive from the original input
2087 // name. Find a clean way to go about this.
2088 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
2089 Args.hasArg(options::OPT_o)) {
2090 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
2091 CmdArgs.push_back("-auxbase-strip");
2092 CmdArgs.push_back(OutputOpt->getValue(Args));
2093 } else {
2094 CmdArgs.push_back("-auxbase");
2095 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
2096 }
2097
2098 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
2099
2100 Args.AddAllArgs(CmdArgs, options::OPT_O);
2101 // FIXME: -Wall is getting some special treatment. Investigate.
2102 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2103 Args.AddLastArg(CmdArgs, options::OPT_w);
2104 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
2105 options::OPT_trigraphs);
2106 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2107 // Honor -std-default.
2108 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2109 "-std=", /*Joined=*/true);
2110 }
2111
2112 if (Args.hasArg(options::OPT_v))
2113 CmdArgs.push_back("-version");
2114 if (Args.hasArg(options::OPT_pg))
2115 CmdArgs.push_back("-p");
2116 Args.AddLastArg(CmdArgs, options::OPT_p);
2117
2118 // The driver treats -fsyntax-only specially.
2119 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2120 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2121 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
2122 // used to inhibit the default -fno-builtin-str{cat,cpy}.
2123 //
2124 // FIXME: Should we grow a better way to deal with "removing" args?
2125 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
2126 options::OPT_fsyntax_only),
2127 ie = Args.filtered_end(); it != ie; ++it) {
2128 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
2129 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
2130 (*it)->claim();
2131 (*it)->render(Args, CmdArgs);
2132 }
2133 }
2134 } else
2135 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2136
2137 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2138 if (Args.hasArg(options::OPT_Qn))
2139 CmdArgs.push_back("-fno-ident");
2140
2141 // FIXME: This isn't correct.
2142 //Args.AddLastArg(CmdArgs, options::OPT__help)
2143 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
2144
2145 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2146
2147 // FIXME: Still don't get what is happening here. Investigate.
2148 Args.AddAllArgs(CmdArgs, options::OPT__param);
2149
2150 if (Args.hasArg(options::OPT_fmudflap) ||
2151 Args.hasArg(options::OPT_fmudflapth)) {
2152 CmdArgs.push_back("-fno-builtin");
2153 CmdArgs.push_back("-fno-merge-constants");
2154 }
2155
2156 if (Args.hasArg(options::OPT_coverage)) {
2157 CmdArgs.push_back("-fprofile-arcs");
2158 CmdArgs.push_back("-ftest-coverage");
2159 }
2160
2161 if (types::isCXX(Inputs[0].getType()))
2162 CmdArgs.push_back("-D__private_extern__=extern");
2163}
2164
2165void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2166 const InputInfoList &Inputs,
2167 const ArgStringList &OutputArgs) const {
2168 // Derived from cpp_options
2169 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
2170
2171 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2172
2173 AddCC1Args(Args, CmdArgs);
2174
2175 // NOTE: The code below has some commonality with cpp_options, but
2176 // in classic gcc style ends up sending things in different
2177 // orders. This may be a good merge candidate once we drop pedantic
2178 // compatibility.
2179
2180 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2181 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
2182 options::OPT_trigraphs);
2183 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2184 // Honor -std-default.
2185 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2186 "-std=", /*Joined=*/true);
2187 }
2188 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2189 Args.AddLastArg(CmdArgs, options::OPT_w);
2190
2191 // The driver treats -fsyntax-only specially.
2192 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2193
2194 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
2195 !Args.hasArg(options::OPT_fno_working_directory))
2196 CmdArgs.push_back("-fworking-directory");
2197
2198 Args.AddAllArgs(CmdArgs, options::OPT_O);
2199 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2200 if (Args.hasArg(options::OPT_save_temps))
2201 CmdArgs.push_back("-fpch-preprocess");
2202}
2203
2204void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
2205 ArgStringList &CmdArgs,
2206 const InputInfoList &Inputs) const {
2207 const Driver &D = getToolChain().getDriver();
2208
2209 CheckPreprocessingOptions(D, Args);
2210
2211 // Derived from cpp_unique_options.
2212 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
2213 Args.AddLastArg(CmdArgs, options::OPT_C);
2214 Args.AddLastArg(CmdArgs, options::OPT_CC);
2215 if (!Args.hasArg(options::OPT_Q))
2216 CmdArgs.push_back("-quiet");
2217 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
2218 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
2219 Args.AddLastArg(CmdArgs, options::OPT_v);
2220 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
2221 Args.AddLastArg(CmdArgs, options::OPT_P);
2222
2223 // FIXME: Handle %I properly.
2224 if (getToolChain().getArchName() == "x86_64") {
2225 CmdArgs.push_back("-imultilib");
2226 CmdArgs.push_back("x86_64");
2227 }
2228
2229 if (Args.hasArg(options::OPT_MD)) {
2230 CmdArgs.push_back("-MD");
2231 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
2232 }
2233
2234 if (Args.hasArg(options::OPT_MMD)) {
2235 CmdArgs.push_back("-MMD");
2236 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
2237 }
2238
2239 Args.AddLastArg(CmdArgs, options::OPT_M);
2240 Args.AddLastArg(CmdArgs, options::OPT_MM);
2241 Args.AddAllArgs(CmdArgs, options::OPT_MF);
2242 Args.AddLastArg(CmdArgs, options::OPT_MG);
2243 Args.AddLastArg(CmdArgs, options::OPT_MP);
2244 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
2245 Args.AddAllArgs(CmdArgs, options::OPT_MT);
2246 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
2247 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
2248 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2249 CmdArgs.push_back("-MQ");
2250 CmdArgs.push_back(OutputOpt->getValue(Args));
2251 }
2252 }
2253
2254 Args.AddLastArg(CmdArgs, options::OPT_remap);
2255 if (Args.hasArg(options::OPT_g3))
2256 CmdArgs.push_back("-dD");
2257 Args.AddLastArg(CmdArgs, options::OPT_H);
2258
2259 AddCPPArgs(Args, CmdArgs);
2260
2261 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
2262 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
2263
2264 for (InputInfoList::const_iterator
2265 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2266 const InputInfo &II = *it;
2267
2268 CmdArgs.push_back(II.getFilename());
2269 }
2270
2271 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
2272 options::OPT_Xpreprocessor);
2273
2274 if (Args.hasArg(options::OPT_fmudflap)) {
2275 CmdArgs.push_back("-D_MUDFLAP");
2276 CmdArgs.push_back("-include");
2277 CmdArgs.push_back("mf-runtime.h");
2278 }
2279
2280 if (Args.hasArg(options::OPT_fmudflapth)) {
2281 CmdArgs.push_back("-D_MUDFLAP");
2282 CmdArgs.push_back("-D_MUDFLAPTH");
2283 CmdArgs.push_back("-include");
2284 CmdArgs.push_back("mf-runtime.h");
2285 }
2286}
2287
2288void darwin::CC1::AddCPPArgs(const ArgList &Args,
2289 ArgStringList &CmdArgs) const {
2290 // Derived from cpp spec.
2291
2292 if (Args.hasArg(options::OPT_static)) {
2293 // The gcc spec is broken here, it refers to dynamic but
2294 // that has been translated. Start by being bug compatible.
2295
2296 // if (!Args.hasArg(arglist.parser.dynamicOption))
2297 CmdArgs.push_back("-D__STATIC__");
2298 } else
2299 CmdArgs.push_back("-D__DYNAMIC__");
2300
2301 if (Args.hasArg(options::OPT_pthread))
2302 CmdArgs.push_back("-D_REENTRANT");
2303}
2304
2305void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
2306 const InputInfo &Output,
2307 const InputInfoList &Inputs,
2308 const ArgList &Args,
2309 const char *LinkingOutput) const {
2310 ArgStringList CmdArgs;
2311
2312 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2313
2314 CmdArgs.push_back("-E");
2315
2316 if (Args.hasArg(options::OPT_traditional) ||
2317 Args.hasArg(options::OPT_traditional_cpp))
2318 CmdArgs.push_back("-traditional-cpp");
2319
2320 ArgStringList OutputArgs;
2321 assert(Output.isFilename() && "Unexpected CC1 output.");
2322 OutputArgs.push_back("-o");
2323 OutputArgs.push_back(Output.getFilename());
2324
2325 if (Args.hasArg(options::OPT_E)) {
2326 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2327 } else {
2328 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2329 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2330 }
2331
2332 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2333
2334 const char *CC1Name = getCC1Name(Inputs[0].getType());
2335 const char *Exec =
2336 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
2337 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2338}
2339
2340void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
2341 const InputInfo &Output,
2342 const InputInfoList &Inputs,
2343 const ArgList &Args,
2344 const char *LinkingOutput) const {
2345 const Driver &D = getToolChain().getDriver();
2346 ArgStringList CmdArgs;
2347
2348 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2349
2350 types::ID InputType = Inputs[0].getType();
2351 const Arg *A;
2352 if ((A = Args.getLastArg(options::OPT_traditional)))
2353 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2354 << A->getAsString(Args) << "-E";
2355
2356 if (JA.getType() == types::TY_LLVM_IR ||
2357 JA.getType() == types::TY_LTO_IR)
2358 CmdArgs.push_back("-emit-llvm");
2359 else if (JA.getType() == types::TY_LLVM_BC ||
2360 JA.getType() == types::TY_LTO_BC)
2361 CmdArgs.push_back("-emit-llvm-bc");
2362 else if (Output.getType() == types::TY_AST)
2363 D.Diag(clang::diag::err_drv_no_ast_support)
2364 << getToolChain().getTripleString();
2365 else if (JA.getType() != types::TY_PP_Asm &&
2366 JA.getType() != types::TY_PCH)
2367 D.Diag(clang::diag::err_drv_invalid_gcc_output_type)
2368 << getTypeName(JA.getType());
2369
2370 ArgStringList OutputArgs;
2371 if (Output.getType() != types::TY_PCH) {
2372 OutputArgs.push_back("-o");
2373 if (Output.isNothing())
2374 OutputArgs.push_back("/dev/null");
2375 else
2376 OutputArgs.push_back(Output.getFilename());
2377 }
2378
2379 // There is no need for this level of compatibility, but it makes
2380 // diffing easier.
2381 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
2382 Args.hasArg(options::OPT_S));
2383
2384 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
2385 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
2386 if (OutputArgsEarly) {
2387 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2388 } else {
2389 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2390 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2391 }
2392 } else {
2393 CmdArgs.push_back("-fpreprocessed");
2394
2395 for (InputInfoList::const_iterator
2396 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2397 const InputInfo &II = *it;
2398
2399 // Reject AST inputs.
2400 if (II.getType() == types::TY_AST) {
2401 D.Diag(clang::diag::err_drv_no_ast_support)
2402 << getToolChain().getTripleString();
2403 return;
2404 }
2405
2406 CmdArgs.push_back(II.getFilename());
2407 }
2408
2409 if (OutputArgsEarly) {
2410 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2411 } else {
2412 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2413 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2414 }
2415 }
2416
2417 if (Output.getType() == types::TY_PCH) {
2418 assert(Output.isFilename() && "Invalid PCH output.");
2419
2420 CmdArgs.push_back("-o");
2421 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
2422 // to be a good reason.
2423 CmdArgs.push_back("/dev/null");
2424
2425 CmdArgs.push_back("--output-pch=");
2426 CmdArgs.push_back(Output.getFilename());
2427 }
2428
2429 const char *CC1Name = getCC1Name(Inputs[0].getType());
2430 const char *Exec =
2431 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
2432 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2433}
2434
2435void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
2436 const InputInfo &Output,
2437 const InputInfoList &Inputs,
2438 const ArgList &Args,
2439 const char *LinkingOutput) const {
2440 ArgStringList CmdArgs;
2441
2442 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2443 const InputInfo &Input = Inputs[0];
2444
2445 // Bit of a hack, this is only used for original inputs.
2446 //
2447 // FIXME: This is broken for preprocessed .s inputs.
2448 if (Input.isFilename() &&
2449 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) {
2450 if (Args.hasArg(options::OPT_gstabs))
2451 CmdArgs.push_back("--gstabs");
2452 else if (Args.hasArg(options::OPT_g_Group))
2453 CmdArgs.push_back("--gdwarf2");
2454 }
2455
2456 // Derived from asm spec.
2457 AddDarwinArch(Args, CmdArgs);
2458
2459 // Use -force_cpusubtype_ALL on x86 by default.
2460 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
2461 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
2462 Args.hasArg(options::OPT_force__cpusubtype__ALL))
2463 CmdArgs.push_back("-force_cpusubtype_ALL");
2464
2465 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
2466 (Args.hasArg(options::OPT_mkernel) ||
2467 Args.hasArg(options::OPT_static) ||
2468 Args.hasArg(options::OPT_fapple_kext)))
2469 CmdArgs.push_back("-static");
2470
2471 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2472 options::OPT_Xassembler);
2473
2474 assert(Output.isFilename() && "Unexpected lipo output.");
2475 CmdArgs.push_back("-o");
2476 CmdArgs.push_back(Output.getFilename());
2477
2478 assert(Input.isFilename() && "Invalid input.");
2479 CmdArgs.push_back(Input.getFilename());
2480
2481 // asm_final spec is empty.
2482
2483 const char *Exec =
2484 Args.MakeArgString(getToolChain().GetProgramPath("as"));
2485 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2486}
2487
2488void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
2489 ArgStringList &CmdArgs) const {
2490 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
2491
2492 // Derived from darwin_arch spec.
2493 CmdArgs.push_back("-arch");
2494 CmdArgs.push_back(Args.MakeArgString(ArchName));
2495
2496 // FIXME: Is this needed anymore?
2497 if (ArchName == "arm")
2498 CmdArgs.push_back("-force_cpusubtype_ALL");
2499}
2500
2501void darwin::Link::AddLinkArgs(Compilation &C,
2502 const ArgList &Args,
2503 ArgStringList &CmdArgs) const {
2504 const Driver &D = getToolChain().getDriver();
2505
2506 unsigned Version[3] = { 0, 0, 0 };
2507 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2508 bool HadExtra;
2509 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
2510 Version[1], Version[2], HadExtra) ||
2511 HadExtra)
2512 D.Diag(clang::diag::err_drv_invalid_version_number)
2513 << A->getAsString(Args);
2514 }
2515
2516 // Newer linkers support -demangle, pass it if supported and not disabled by
2517 // the user.
2518 //
2519 // FIXME: We temporarily avoid passing -demangle to any iOS linker, because
2520 // unfortunately we can't be guaranteed that the linker version used there
2521 // will match the linker version detected at configure time. We need the
2522 // universal driver.
2523 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) &&
2524 !getDarwinToolChain().isTargetIPhoneOS()) {
2525 // Don't pass -demangle to ld_classic.
2526 //
2527 // FIXME: This is a temporary workaround, ld should be handling this.
2528 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
2529 Args.hasArg(options::OPT_static));
2530 if (getToolChain().getArch() == llvm::Triple::x86) {
2531 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
2532 options::OPT_Wl_COMMA),
2533 ie = Args.filtered_end(); it != ie; ++it) {
2534 const Arg *A = *it;
2535 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
2536 if (llvm::StringRef(A->getValue(Args, i)) == "-kext")
2537 UsesLdClassic = true;
2538 }
2539 }
2540 if (!UsesLdClassic)
2541 CmdArgs.push_back("-demangle");
2542 }
2543
2544 // Derived from the "link" spec.
2545 Args.AddAllArgs(CmdArgs, options::OPT_static);
2546 if (!Args.hasArg(options::OPT_static))
2547 CmdArgs.push_back("-dynamic");
2548 if (Args.hasArg(options::OPT_fgnu_runtime)) {
2549 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
2550 // here. How do we wish to handle such things?
2551 }
2552
2553 if (!Args.hasArg(options::OPT_dynamiclib)) {
2554 AddDarwinArch(Args, CmdArgs);
2555 // FIXME: Why do this only on this path?
2556 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
2557
2558 Args.AddLastArg(CmdArgs, options::OPT_bundle);
2559 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
2560 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
2561
2562 Arg *A;
2563 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
2564 (A = Args.getLastArg(options::OPT_current__version)) ||
2565 (A = Args.getLastArg(options::OPT_install__name)))
2566 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
2567 << A->getAsString(Args) << "-dynamiclib";
2568
2569 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
2570 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
2571 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
2572 } else {
2573 CmdArgs.push_back("-dylib");
2574
2575 Arg *A;
2576 if ((A = Args.getLastArg(options::OPT_bundle)) ||
2577 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
2578 (A = Args.getLastArg(options::OPT_client__name)) ||
2579 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
2580 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
2581 (A = Args.getLastArg(options::OPT_private__bundle)))
2582 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
2583 << A->getAsString(Args) << "-dynamiclib";
2584
2585 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
2586 "-dylib_compatibility_version");
2587 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
2588 "-dylib_current_version");
2589
2590 AddDarwinArch(Args, CmdArgs);
2591
2592 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
2593 "-dylib_install_name");
2594 }
2595
2596 Args.AddLastArg(CmdArgs, options::OPT_all__load);
2597 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
2598 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
2599 if (getDarwinToolChain().isTargetIPhoneOS())
2600 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
2601 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
2602 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
2603 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
2604 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
2605 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
2606 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
2607 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
2608 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
2609 Args.AddAllArgs(CmdArgs, options::OPT_init);
2610
2611 // Adding all arguments doesn't make sense here but this is what gcc does. One
2612 // of this should always be present thanks to argument translation.
2613 assert((Args.hasArg(options::OPT_mmacosx_version_min_EQ) ||
2614 Args.hasArg(options::OPT_miphoneos_version_min_EQ)) &&
2615 "Missing version argument (lost in translation)?");
2616 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ,
2617 "-macosx_version_min");
2618 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ,
2619 "-iphoneos_version_min");
2620 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
2621 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
2622 Args.AddLastArg(CmdArgs, options::OPT_single__module);
2623 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
2624 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
2625
2626 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
2627 options::OPT_fno_pie,
2628 options::OPT_fno_PIE)) {
2629 if (A->getOption().matches(options::OPT_fpie) ||
2630 A->getOption().matches(options::OPT_fPIE))
2631 CmdArgs.push_back("-pie");
2632 else
2633 CmdArgs.push_back("-no_pie");
2634 }
2635
2636 Args.AddLastArg(CmdArgs, options::OPT_prebind);
2637 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
2638 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
2639 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
2640 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
2641 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
2642 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
2643 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
2644 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
2645 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
2646 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
2647 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
2648 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
2649 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
2650 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
2651 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
2652
2653 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot");
2654 if (getDarwinToolChain().isTargetIPhoneOS()) {
2655 if (!Args.hasArg(options::OPT_isysroot)) {
2656 CmdArgs.push_back("-syslibroot");
2657 CmdArgs.push_back("/Developer/SDKs/Extra");
2658 }
2659 }
2660
2661 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
2662 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
2663 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
2664 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
2665 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
2666 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
2667 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
2668 Args.AddAllArgs(CmdArgs, options::OPT_y);
2669 Args.AddLastArg(CmdArgs, options::OPT_w);
2670 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
2671 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
2672 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
2673 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
2674 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
2675 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
2676 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
2677 Args.AddLastArg(CmdArgs, options::OPT_whyload);
2678 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
2679 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
2680 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
2681 Args.AddLastArg(CmdArgs, options::OPT_Mach);
2682}
2683
2684void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
2685 const InputInfo &Output,
2686 const InputInfoList &Inputs,
2687 const ArgList &Args,
2688 const char *LinkingOutput) const {
2689 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
2690
2691 // The logic here is derived from gcc's behavior; most of which
2692 // comes from specs (starting with link_command). Consult gcc for
2693 // more information.
2694 ArgStringList CmdArgs;
2695
2696 // I'm not sure why this particular decomposition exists in gcc, but
2697 // we follow suite for ease of comparison.
2698 AddLinkArgs(C, Args, CmdArgs);
2699
2700 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
2701 Args.AddAllArgs(CmdArgs, options::OPT_s);
2702 Args.AddAllArgs(CmdArgs, options::OPT_t);
2703 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
2704 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
2705 Args.AddAllArgs(CmdArgs, options::OPT_A);
2706 Args.AddLastArg(CmdArgs, options::OPT_e);
2707 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
2708 Args.AddAllArgs(CmdArgs, options::OPT_r);
2709
2710 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
2711 // members of static archive libraries which implement Objective-C classes or
2712 // categories.
2713 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
2714 CmdArgs.push_back("-ObjC");
2715
2716 CmdArgs.push_back("-o");
2717 CmdArgs.push_back(Output.getFilename());
2718
2719 if (!Args.hasArg(options::OPT_A) &&
2720 !Args.hasArg(options::OPT_nostdlib) &&
2721 !Args.hasArg(options::OPT_nostartfiles)) {
2722 // Derived from startfile spec.
2723 if (Args.hasArg(options::OPT_dynamiclib)) {
2724 // Derived from darwin_dylib1 spec.
2725 if (getDarwinToolChain().isTargetIPhoneOS()) {
2726 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
2727 CmdArgs.push_back("-ldylib1.o");
2728 } else {
2729 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
2730 CmdArgs.push_back("-ldylib1.o");
2731 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
2732 CmdArgs.push_back("-ldylib1.10.5.o");
2733 }
2734 } else {
2735 if (Args.hasArg(options::OPT_bundle)) {
2736 if (!Args.hasArg(options::OPT_static)) {
2737 // Derived from darwin_bundle1 spec.
2738 if (getDarwinToolChain().isTargetIPhoneOS()) {
2739 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
2740 CmdArgs.push_back("-lbundle1.o");
2741 } else {
2742 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
2743 CmdArgs.push_back("-lbundle1.o");
2744 }
2745 }
2746 } else {
2747 if (Args.hasArg(options::OPT_pg)) {
2748 if (Args.hasArg(options::OPT_static) ||
2749 Args.hasArg(options::OPT_object) ||
2750 Args.hasArg(options::OPT_preload)) {
2751 CmdArgs.push_back("-lgcrt0.o");
2752 } else {
2753 CmdArgs.push_back("-lgcrt1.o");
2754
2755 // darwin_crt2 spec is empty.
2756 }
2757 } else {
2758 if (Args.hasArg(options::OPT_static) ||
2759 Args.hasArg(options::OPT_object) ||
2760 Args.hasArg(options::OPT_preload)) {
2761 CmdArgs.push_back("-lcrt0.o");
2762 } else {
2763 // Derived from darwin_crt1 spec.
2764 if (getDarwinToolChain().isTargetIPhoneOS()) {
2765 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
2766 CmdArgs.push_back("-lcrt1.o");
2767 else
2768 CmdArgs.push_back("-lcrt1.3.1.o");
2769 } else {
2770 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
2771 CmdArgs.push_back("-lcrt1.o");
2772 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
2773 CmdArgs.push_back("-lcrt1.10.5.o");
2774 else
2775 CmdArgs.push_back("-lcrt1.10.6.o");
2776
2777 // darwin_crt2 spec is empty.
2778 }
2779 }
2780 }
2781 }
2782 }
2783
2784 if (!getDarwinToolChain().isTargetIPhoneOS() &&
2785 Args.hasArg(options::OPT_shared_libgcc) &&
2786 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
2787 const char *Str =
2788 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
2789 CmdArgs.push_back(Str);
2790 }
2791 }
2792
2793 Args.AddAllArgs(CmdArgs, options::OPT_L);
2794
2795 if (Args.hasArg(options::OPT_fopenmp))
2796 // This is more complicated in gcc...
2797 CmdArgs.push_back("-lgomp");
2798
2799 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
2800
2801 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
2802
2803 if (LinkingOutput) {
2804 CmdArgs.push_back("-arch_multiple");
2805 CmdArgs.push_back("-final_output");
2806 CmdArgs.push_back(LinkingOutput);
2807 }
2808
2809 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2810 Args.hasArg(options::OPT_fprofile_generate) ||
2811 Args.hasArg(options::OPT_fcreate_profile) ||
2812 Args.hasArg(options::OPT_coverage))
2813 CmdArgs.push_back("-lgcov");
2814
2815 if (Args.hasArg(options::OPT_fnested_functions))
2816 CmdArgs.push_back("-allow_stack_execute");
2817
2818 if (!Args.hasArg(options::OPT_nostdlib) &&
2819 !Args.hasArg(options::OPT_nodefaultlibs)) {
2820 if (getToolChain().getDriver().CCCIsCXX)
2821 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
2822
2823 // link_ssp spec is empty.
2824
2825 // Let the tool chain choose which runtime library to link.
2826 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
2827 }
2828
2829 if (!Args.hasArg(options::OPT_A) &&
2830 !Args.hasArg(options::OPT_nostdlib) &&
2831 !Args.hasArg(options::OPT_nostartfiles)) {
2832 // endfile_spec is empty.
2833 }
2834
2835 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
2836 Args.AddAllArgs(CmdArgs, options::OPT_F);
2837
2838 const char *Exec =
2839 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
2840 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2841}
2842
2843void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
2844 const InputInfo &Output,
2845 const InputInfoList &Inputs,
2846 const ArgList &Args,
2847 const char *LinkingOutput) const {
2848 ArgStringList CmdArgs;
2849
2850 CmdArgs.push_back("-create");
2851 assert(Output.isFilename() && "Unexpected lipo output.");
2852
2853 CmdArgs.push_back("-output");
2854 CmdArgs.push_back(Output.getFilename());
2855
2856 for (InputInfoList::const_iterator
2857 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2858 const InputInfo &II = *it;
2859 assert(II.isFilename() && "Unexpected lipo input.");
2860 CmdArgs.push_back(II.getFilename());
2861 }
2862 const char *Exec =
2863 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
2864 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2865}
2866
2867void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
2868 const InputInfo &Output,
2869 const InputInfoList &Inputs,
2870 const ArgList &Args,
2871 const char *LinkingOutput) const {
2872 ArgStringList CmdArgs;
2873
2874 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2875 const InputInfo &Input = Inputs[0];
2876 assert(Input.isFilename() && "Unexpected dsymutil input.");
2877 CmdArgs.push_back(Input.getFilename());
2878
2879 CmdArgs.push_back("-o");
2880 CmdArgs.push_back(Output.getFilename());
2881
2882 const char *Exec =
2883 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
2884 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2885}
2886
2887void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
2888 const InputInfo &Output,
2889 const InputInfoList &Inputs,
2890 const ArgList &Args,
2891 const char *LinkingOutput) const {
2892 ArgStringList CmdArgs;
2893
2894 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2895 options::OPT_Xassembler);
2896
2897 CmdArgs.push_back("-o");
2898 CmdArgs.push_back(Output.getFilename());
2899
2900 for (InputInfoList::const_iterator
2901 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2902 const InputInfo &II = *it;
2903 CmdArgs.push_back(II.getFilename());
2904 }
2905
2906 const char *Exec =
2907 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
2908 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2909}
2910
2911void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
2912 const InputInfo &Output,
2913 const InputInfoList &Inputs,
2914 const ArgList &Args,
2915 const char *LinkingOutput) const {
2916 ArgStringList CmdArgs;
2917
2918 if ((!Args.hasArg(options::OPT_nostdlib)) &&
2919 (!Args.hasArg(options::OPT_shared))) {
2920 CmdArgs.push_back("-e");
2921 CmdArgs.push_back("_start");
2922 }
2923
2924 if (Args.hasArg(options::OPT_static)) {
2925 CmdArgs.push_back("-Bstatic");
2926 CmdArgs.push_back("-dn");
2927 } else {
2928// CmdArgs.push_back("--eh-frame-hdr");
2929 CmdArgs.push_back("-Bdynamic");
2930 if (Args.hasArg(options::OPT_shared)) {
2931 CmdArgs.push_back("-shared");
2932 } else {
2933 CmdArgs.push_back("--dynamic-linker");
2934 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
2935 }
2936 }
2937
2938 if (Output.isFilename()) {
2939 CmdArgs.push_back("-o");
2940 CmdArgs.push_back(Output.getFilename());
2941 } else {
2942 assert(Output.isNothing() && "Invalid output.");
2943 }
2944
2945 if (!Args.hasArg(options::OPT_nostdlib) &&
2946 !Args.hasArg(options::OPT_nostartfiles)) {
2947 if (!Args.hasArg(options::OPT_shared)) {
2948 CmdArgs.push_back(Args.MakeArgString(
2949 getToolChain().GetFilePath("crt1.o")));
2950 CmdArgs.push_back(Args.MakeArgString(
2951 getToolChain().GetFilePath("crti.o")));
2952 CmdArgs.push_back(Args.MakeArgString(
2953 getToolChain().GetFilePath("crtbegin.o")));
2954 } else {
2955 CmdArgs.push_back(Args.MakeArgString(
2956 getToolChain().GetFilePath("crti.o")));
2957 }
2958 CmdArgs.push_back(Args.MakeArgString(
2959 getToolChain().GetFilePath("crtn.o")));
2960 }
2961
2962 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
2963 + getToolChain().getTripleString()
2964 + "/4.2.4"));
2965
2966 Args.AddAllArgs(CmdArgs, options::OPT_L);
2967 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
2968 Args.AddAllArgs(CmdArgs, options::OPT_e);
2969
2970 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
2971
2972 if (!Args.hasArg(options::OPT_nostdlib) &&
2973 !Args.hasArg(options::OPT_nodefaultlibs)) {
2974 // FIXME: For some reason GCC passes -lgcc before adding
2975 // the default system libraries. Just mimic this for now.
2976 CmdArgs.push_back("-lgcc");
2977
2978 if (Args.hasArg(options::OPT_pthread))
2979 CmdArgs.push_back("-pthread");
2980 if (!Args.hasArg(options::OPT_shared))
2981 CmdArgs.push_back("-lc");
2982 CmdArgs.push_back("-lgcc");
2983 }
2984
2985 if (!Args.hasArg(options::OPT_nostdlib) &&
2986 !Args.hasArg(options::OPT_nostartfiles)) {
2987 if (!Args.hasArg(options::OPT_shared))
2988 CmdArgs.push_back(Args.MakeArgString(
2989 getToolChain().GetFilePath("crtend.o")));
2990 }
2991
2992 const char *Exec =
2993 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
2994 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2995}
2996
2997void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
2998 const InputInfo &Output,
2999 const InputInfoList &Inputs,
3000 const ArgList &Args,
3001 const char *LinkingOutput) const {
3002 ArgStringList CmdArgs;
3003
3004 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3005 options::OPT_Xassembler);
3006
3007 CmdArgs.push_back("-o");
3008 CmdArgs.push_back(Output.getFilename());
3009
3010 for (InputInfoList::const_iterator
3011 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3012 const InputInfo &II = *it;
3013 CmdArgs.push_back(II.getFilename());
3014 }
3015
3016 const char *Exec =
3017 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3018 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3019}
3020
3021void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3022 const InputInfo &Output,
3023 const InputInfoList &Inputs,
3024 const ArgList &Args,
3025 const char *LinkingOutput) const {
3026 const Driver &D = getToolChain().getDriver();
3027 ArgStringList CmdArgs;
3028
3029 if ((!Args.hasArg(options::OPT_nostdlib)) &&
3030 (!Args.hasArg(options::OPT_shared))) {
3031 CmdArgs.push_back("-e");
3032 CmdArgs.push_back("__start");
3033 }
3034
3035 if (Args.hasArg(options::OPT_static)) {
3036 CmdArgs.push_back("-Bstatic");
3037 } else {
3038 if (Args.hasArg(options::OPT_rdynamic))
3039 CmdArgs.push_back("-export-dynamic");
3040 CmdArgs.push_back("--eh-frame-hdr");
3041 CmdArgs.push_back("-Bdynamic");
3042 if (Args.hasArg(options::OPT_shared)) {
3043 CmdArgs.push_back("-shared");
3044 } else {
3045 CmdArgs.push_back("-dynamic-linker");
3046 CmdArgs.push_back("/usr/libexec/ld.so");
3047 }
3048 }
3049
3050 if (Output.isFilename()) {
3051 CmdArgs.push_back("-o");
3052 CmdArgs.push_back(Output.getFilename());
3053 } else {
3054 assert(Output.isNothing() && "Invalid output.");
3055 }
3056
3057 if (!Args.hasArg(options::OPT_nostdlib) &&
3058 !Args.hasArg(options::OPT_nostartfiles)) {
3059 if (!Args.hasArg(options::OPT_shared)) {
3060 CmdArgs.push_back(Args.MakeArgString(
3061 getToolChain().GetFilePath("crt0.o")));
3062 CmdArgs.push_back(Args.MakeArgString(
3063 getToolChain().GetFilePath("crtbegin.o")));
3064 } else {
3065 CmdArgs.push_back(Args.MakeArgString(
3066 getToolChain().GetFilePath("crtbeginS.o")));
3067 }
3068 }
3069
3070 std::string Triple = getToolChain().getTripleString();
3071 if (Triple.substr(0, 6) == "x86_64")
3072 Triple.replace(0, 6, "amd64");
3073 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
3074 "/4.2.1"));
3075
3076 Args.AddAllArgs(CmdArgs, options::OPT_L);
3077 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3078 Args.AddAllArgs(CmdArgs, options::OPT_e);
3079
3080 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3081
3082 if (!Args.hasArg(options::OPT_nostdlib) &&
3083 !Args.hasArg(options::OPT_nodefaultlibs)) {
3084 if (D.CCCIsCXX) {
3085 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3086 CmdArgs.push_back("-lm");
3087 }
3088
3089 // FIXME: For some reason GCC passes -lgcc before adding
3090 // the default system libraries. Just mimic this for now.
3091 CmdArgs.push_back("-lgcc");
3092
3093 if (Args.hasArg(options::OPT_pthread))
3094 CmdArgs.push_back("-pthread");
3095 if (!Args.hasArg(options::OPT_shared))
3096 CmdArgs.push_back("-lc");
3097 CmdArgs.push_back("-lgcc");
3098 }
3099
3100 if (!Args.hasArg(options::OPT_nostdlib) &&
3101 !Args.hasArg(options::OPT_nostartfiles)) {
3102 if (!Args.hasArg(options::OPT_shared))
3103 CmdArgs.push_back(Args.MakeArgString(
3104 getToolChain().GetFilePath("crtend.o")));
3105 else
3106 CmdArgs.push_back(Args.MakeArgString(
3107 getToolChain().GetFilePath("crtendS.o")));
3108 }
3109
3110 const char *Exec =
3111 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3112 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3113}
3114
3115void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3116 const InputInfo &Output,
3117 const InputInfoList &Inputs,
3118 const ArgList &Args,
3119 const char *LinkingOutput) const {
3120 ArgStringList CmdArgs;
3121
3122 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3123 // instruct as in the base system to assemble 32-bit code.
3124 if (getToolChain().getArchName() == "i386")
3125 CmdArgs.push_back("--32");
3126
3127
3128 // Set byte order explicitly
3129 if (getToolChain().getArchName() == "mips")
3130 CmdArgs.push_back("-EB");
3131 else if (getToolChain().getArchName() == "mipsel")
3132 CmdArgs.push_back("-EL");
3133
3134 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3135 options::OPT_Xassembler);
3136
3137 CmdArgs.push_back("-o");
3138 CmdArgs.push_back(Output.getFilename());
3139
3140 for (InputInfoList::const_iterator
3141 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3142 const InputInfo &II = *it;
3143 CmdArgs.push_back(II.getFilename());
3144 }
3145
3146 const char *Exec =
3147 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3148 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3149}
3150
3151void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3152 const InputInfo &Output,
3153 const InputInfoList &Inputs,
3154 const ArgList &Args,
3155 const char *LinkingOutput) const {
3156 const Driver &D = getToolChain().getDriver();
3157 ArgStringList CmdArgs;
3158
3159 if (Args.hasArg(options::OPT_static)) {
3160 CmdArgs.push_back("-Bstatic");
3161 } else {
3162 if (Args.hasArg(options::OPT_rdynamic))
3163 CmdArgs.push_back("-export-dynamic");
3164 CmdArgs.push_back("--eh-frame-hdr");
3165 if (Args.hasArg(options::OPT_shared)) {
3166 CmdArgs.push_back("-Bshareable");
3167 } else {
3168 CmdArgs.push_back("-dynamic-linker");
3169 CmdArgs.push_back("/libexec/ld-elf.so.1");
3170 }
3171 }
3172
3173 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3174 // instruct ld in the base system to link 32-bit code.
3175 if (getToolChain().getArchName() == "i386") {
3176 CmdArgs.push_back("-m");
3177 CmdArgs.push_back("elf_i386_fbsd");
3178 }
3179
3180 if (Output.isFilename()) {
3181 CmdArgs.push_back("-o");
3182 CmdArgs.push_back(Output.getFilename());
3183 } else {
3184 assert(Output.isNothing() && "Invalid output.");
3185 }
3186
3187 if (!Args.hasArg(options::OPT_nostdlib) &&
3188 !Args.hasArg(options::OPT_nostartfiles)) {
3189 if (!Args.hasArg(options::OPT_shared)) {
3190 if (Args.hasArg(options::OPT_pg))
3191 CmdArgs.push_back(Args.MakeArgString(
3192 getToolChain().GetFilePath("gcrt1.o")));
3193 else
3194 CmdArgs.push_back(Args.MakeArgString(
3195 getToolChain().GetFilePath("crt1.o")));
3196 CmdArgs.push_back(Args.MakeArgString(
3197 getToolChain().GetFilePath("crti.o")));
3198 CmdArgs.push_back(Args.MakeArgString(
3199 getToolChain().GetFilePath("crtbegin.o")));
3200 } else {
3201 CmdArgs.push_back(Args.MakeArgString(
3202 getToolChain().GetFilePath("crti.o")));
3203 CmdArgs.push_back(Args.MakeArgString(
3204 getToolChain().GetFilePath("crtbeginS.o")));
3205 }
3206 }
3207
3208 Args.AddAllArgs(CmdArgs, options::OPT_L);
|