blob: 7506c4ca8ee0cfbb1f6da60c8244b682b4d5f449 [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000011#include "InputInfo.h"
12#include "SanitizerArgs.h"
13#include "ToolChains.h"
14#include "clang/Basic/ObjCRuntime.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000015#include "clang/Driver/Action.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000016#include "clang/Driver/Arg.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000017#include "clang/Driver/ArgList.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000018#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000019#include "clang/Driver/Driver.h"
20#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000021#include "clang/Driver/Job.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000022#include "clang/Driver/Option.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000023#include "clang/Driver/Options.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000024#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000025#include "clang/Driver/Util.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000026#include "llvm/ADT/SmallString.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000027#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000028#include "llvm/ADT/Twine.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000029#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000030#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000031#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000032#include "llvm/Support/Host.h"
33#include "llvm/Support/Process.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000034#include "llvm/Support/raw_ostream.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000035
Daniel Dunbar1a093d22009-03-18 06:00:36 +000036using namespace clang::driver;
37using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000038using namespace clang;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000039
Daniel Dunbar64198ef2009-09-10 01:21:05 +000040/// 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))
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +000044 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
Chris Lattner0e62c1c2011-07-23 10:55:15 +000045 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar64198ef2009-09-10 01:21:05 +000046 << A->getAsString(Args) << "-E";
47}
48
Daniel Dunbar4eadb602009-09-10 01:21:12 +000049/// 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))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000056 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000057 << A->getAsString(Args) << "-static";
58}
59
Chris Lattnerbf2803f2010-03-29 17:55:58 +000060// Quote target names for inclusion in GNU Make dependency files.
61// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000062static void QuoteTarget(StringRef Target,
63 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000064 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
Bill Wendlingc0938f32012-03-12 22:10:06 +000089static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +000090 ArgStringList &CmdArgs,
91 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +000092 const char *EnvVar) {
93 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +000094 bool CombinedArg = false;
95
Bill Wendling281ca292012-03-12 21:22:35 +000096 if (!DirList)
97 return; // Nothing to do.
98
Chad Rosier616e8a52012-10-30 21:42:09 +000099 StringRef Name(ArgName);
100 if (Name.equals("-I") || Name.equals("-L"))
101 CombinedArg = true;
102
Bill Wendling281ca292012-03-12 21:22:35 +0000103 StringRef Dirs(DirList);
104 if (Dirs.empty()) // Empty string should not add '.'.
105 return;
106
107 StringRef::size_type Delim;
108 while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
109 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000110 if (CombinedArg) {
111 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
112 } else {
113 CmdArgs.push_back(ArgName);
114 CmdArgs.push_back(".");
115 }
Bill Wendling281ca292012-03-12 21:22:35 +0000116 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000117 if (CombinedArg) {
118 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
119 } else {
120 CmdArgs.push_back(ArgName);
121 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
122 }
Bill Wendling281ca292012-03-12 21:22:35 +0000123 }
Nico Weber89355782012-03-19 15:00:03 +0000124 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000125 }
126
127 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000128 if (CombinedArg) {
129 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
130 } else {
131 CmdArgs.push_back(ArgName);
132 CmdArgs.push_back(".");
133 }
Bill Wendling281ca292012-03-12 21:22:35 +0000134 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000135 if (CombinedArg) {
136 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
137 } else {
138 CmdArgs.push_back(ArgName);
139 CmdArgs.push_back(Args.MakeArgString(Dirs));
140 }
Bill Wendling281ca292012-03-12 21:22:35 +0000141 }
142}
143
Daniel Dunbar54423b22010-09-17 00:24:54 +0000144static void AddLinkerInputs(const ToolChain &TC,
145 const InputInfoList &Inputs, const ArgList &Args,
146 ArgStringList &CmdArgs) {
147 const Driver &D = TC.getDriver();
148
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000149 // Add extra linker input arguments which are not treated as inputs
150 // (constructed via -Xarch_).
151 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
152
Daniel Dunbar54423b22010-09-17 00:24:54 +0000153 for (InputInfoList::const_iterator
154 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
155 const InputInfo &II = *it;
156
157 if (!TC.HasNativeLLVMSupport()) {
158 // Don't try to pass LLVM inputs unless we have native support.
159 if (II.getType() == types::TY_LLVM_IR ||
160 II.getType() == types::TY_LTO_IR ||
161 II.getType() == types::TY_LLVM_BC ||
162 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000163 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000164 << TC.getTripleString();
165 }
166
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000167 // Add filenames immediately.
168 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000169 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000170 continue;
171 }
172
173 // Otherwise, this is a linker input argument.
174 const Arg &A = II.getInputArg();
175
176 // Handle reserved library options.
177 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000178 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000179 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
180 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000181 } else
182 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000183 }
Bill Wendling281ca292012-03-12 21:22:35 +0000184
185 // LIBRARY_PATH - included following the user specified library paths.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000186 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000187}
188
John McCall31168b02011-06-15 23:02:42 +0000189/// \brief Determine whether Objective-C automated reference counting is
190/// enabled.
191static bool isObjCAutoRefCount(const ArgList &Args) {
192 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
193}
194
Ted Kremeneke65b0862012-03-06 20:05:56 +0000195/// \brief Determine whether we are linking the ObjC runtime.
196static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000197 if (isObjCAutoRefCount(Args)) {
198 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000199 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000200 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000201 return Args.hasArg(options::OPT_fobjc_link_runtime);
202}
203
Rafael Espindola9d4a8cf2011-06-02 18:58:46 +0000204static void addProfileRT(const ToolChain &TC, const ArgList &Args,
Bill Wendling08760582011-06-27 19:15:03 +0000205 ArgStringList &CmdArgs,
206 llvm::Triple Triple) {
207 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
208 Args.hasArg(options::OPT_fprofile_generate) ||
209 Args.hasArg(options::OPT_fcreate_profile) ||
210 Args.hasArg(options::OPT_coverage)))
211 return;
212
213 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
214 // the link line. We cannot do the same thing because unlike gcov there is a
215 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
216 // not supported by old linkers.
Benjamin Kramerf5fbe432011-11-07 16:02:25 +0000217 std::string ProfileRT =
218 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
Bill Wendling08760582011-06-27 19:15:03 +0000219
Bill Wendling08760582011-06-27 19:15:03 +0000220 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
Rafael Espindola9d4a8cf2011-06-02 18:58:46 +0000221}
222
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000223static bool forwardToGCC(const Option &O) {
224 return !O.hasFlag(options::NoForward) &&
225 !O.hasFlag(options::DriverOption) &&
226 !O.hasFlag(options::LinkerInput);
227}
228
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000229void Clang::AddPreprocessingOptions(Compilation &C,
230 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000231 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000232 ArgStringList &CmdArgs,
233 const InputInfo &Output,
234 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000235 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000236
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000237 CheckPreprocessingOptions(D, Args);
238
239 Args.AddLastArg(CmdArgs, options::OPT_C);
240 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000241
242 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000243 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000244 (A = Args.getLastArg(options::OPT_MD)) ||
245 (A = Args.getLastArg(options::OPT_MMD))) {
246 // Determine the output location.
247 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000248 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000249 DepFile = MF->getValue();
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000250 C.addFailureResultFile(DepFile);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000251 } else if (Output.getType() == types::TY_Dependencies) {
252 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000253 } else if (A->getOption().matches(options::OPT_M) ||
254 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000255 DepFile = "-";
256 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000257 DepFile = getDependencyFileName(Args, Inputs);
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000258 C.addFailureResultFile(DepFile);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000259 }
260 CmdArgs.push_back("-dependency-file");
261 CmdArgs.push_back(DepFile);
262
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000263 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000264 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
265 const char *DepTarget;
266
267 // If user provided -o, that is the dependency target, except
268 // when we are only generating a dependency file.
269 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
270 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000271 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000272 } else {
273 // Otherwise derive from the base input.
274 //
275 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000276 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000277 llvm::sys::path::replace_extension(P, "o");
278 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000279 }
280
281 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000282 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000283 QuoteTarget(DepTarget, Quoted);
284 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000285 }
286
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000287 if (A->getOption().matches(options::OPT_M) ||
288 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000289 CmdArgs.push_back("-sys-header-deps");
290 }
291
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000292 if (Args.hasArg(options::OPT_MG)) {
293 if (!A || A->getOption().matches(options::OPT_MD) ||
294 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000295 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000296 CmdArgs.push_back("-MG");
297 }
298
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000299 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000300
301 // Convert all -MQ <target> args to -MT <quoted target>
302 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
303 options::OPT_MQ),
304 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000305 const Arg *A = *it;
306 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000307
Daniel Dunbara442fd52010-06-11 22:00:13 +0000308 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000309 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000310 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000311 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000312 CmdArgs.push_back(Args.MakeArgString(Quoted));
313
314 // -MT flag - no change
315 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000316 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000317 }
318 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000319
Douglas Gregor111af7d2009-04-18 00:34:01 +0000320 // Add -i* options, and automatically translate to
321 // -include-pch/-include-pth for transparent PCH support. It's
322 // wonky, but we include looking for .gch so we can support seamless
323 // replacement into a build system already set up to be generating
324 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000325 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000326 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
327 ie = Args.filtered_end(); it != ie; ++it) {
328 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000329
330 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000331 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
332 RenderedImplicitInclude = true;
333
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000334 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000335 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000336
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000337 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000338 bool FoundPCH = false;
Richard Smithbd55daf2012-11-01 04:30:05 +0000339 llvm::sys::Path P(A->getValue());
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000340 bool Exists;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000341 if (UsePCH) {
Douglas Gregor111af7d2009-04-18 00:34:01 +0000342 P.appendSuffix("pch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000343 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000344 FoundPCH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000345 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000346 P.eraseSuffix();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000347 }
348
Douglas Gregor111af7d2009-04-18 00:34:01 +0000349 if (!FoundPCH) {
350 P.appendSuffix("pth");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000351 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000352 FoundPTH = true;
353 else
354 P.eraseSuffix();
Mike Stump11289f42009-09-09 15:08:12 +0000355 }
356
Douglas Gregor111af7d2009-04-18 00:34:01 +0000357 if (!FoundPCH && !FoundPTH) {
358 P.appendSuffix("gch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000359 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000360 FoundPCH = UsePCH;
361 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000362 }
Mike Stump11289f42009-09-09 15:08:12 +0000363 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000364 P.eraseSuffix();
365 }
366
367 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000368 if (IsFirstImplicitInclude) {
369 A->claim();
370 if (UsePCH)
371 CmdArgs.push_back("-include-pch");
372 else
373 CmdArgs.push_back("-include-pth");
374 CmdArgs.push_back(Args.MakeArgString(P.str()));
375 continue;
376 } else {
377 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000378 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000379 << P.str() << A->getAsString(Args);
380 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000381 }
382 }
383
384 // Not translated, render as usual.
385 A->claim();
386 A->render(Args, CmdArgs);
387 }
388
389 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000390 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
391 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000392
393 // Add -Wp, and -Xassembler if using the preprocessor.
394
395 // FIXME: There is a very unfortunate problem here, some troubled
396 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
397 // really support that we would have to parse and then translate
398 // those options. :(
399 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
400 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000401
402 // -I- is a deprecated GCC feature, reject it.
403 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000404 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000405
406 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
407 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000408 StringRef sysroot = C.getSysRoot();
409 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000410 if (!Args.hasArg(options::OPT_isysroot)) {
411 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000412 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000413 }
414 }
Douglas Gregorf936f782011-09-14 20:28:46 +0000415
416 // If a module path was provided, pass it along. Otherwise, use a temporary
417 // directory.
418 if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) {
Douglas Gregorf936f782011-09-14 20:28:46 +0000419 A->claim();
420 A->render(Args, CmdArgs);
421 } else {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000422 SmallString<128> DefaultModuleCache;
Douglas Gregorf936f782011-09-14 20:28:46 +0000423 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
424 DefaultModuleCache);
425 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
426 CmdArgs.push_back("-fmodule-cache-path");
427 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
428 }
Douglas Gregor97eec242011-09-15 22:00:41 +0000429
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000430 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000431 // FIXME: We should probably sink the logic for handling these from the
432 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000433 // CPATH - included following the user specified includes (but prior to
434 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000435 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000436 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000437 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000438 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000439 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000440 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000441 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000442 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000443 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000444
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000445 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000446 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000447 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000448
449 // Add system include arguments.
450 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000451}
452
Daniel Dunbarf492c922009-09-10 22:59:51 +0000453/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000454/// CPU.
455//
456// FIXME: This is redundant with -mcpu, why does LLVM use this.
457// FIXME: tblgen this, or kill it!
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000458static const char *getLLVMArchSuffixForARM(StringRef CPU) {
Chad Rosier9ac84512011-10-07 17:48:56 +0000459 return llvm::StringSwitch<const char *>(CPU)
460 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
461 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
462 .Cases("arm920", "arm920t", "arm922t", "v4t")
463 .Cases("arm940t", "ep9312","v4t")
464 .Cases("arm10tdmi", "arm1020t", "v5")
465 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
466 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
467 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
468 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
469 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
470 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Quentin Colombet2e9952e2012-11-29 23:15:27 +0000471 .Cases("cortex-a5", "cortex-a8", "cortex-a9", "cortex-a15", "v7")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000472 .Case("cortex-m3", "v7m")
Jim Grosbach903e63f2012-03-29 19:53:34 +0000473 .Case("cortex-m4", "v7m")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000474 .Case("cortex-m0", "v6m")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000475 .Case("cortex-a9-mp", "v7f")
476 .Case("swift", "v7s")
Chad Rosier9ac84512011-10-07 17:48:56 +0000477 .Default("");
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000478}
479
Benjamin Kramer09811c72012-06-26 22:20:06 +0000480/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
481//
482// FIXME: tblgen this.
483static std::string getARMTargetCPU(const ArgList &Args,
484 const llvm::Triple &Triple) {
485 // FIXME: Warn on inconsistent use of -mcpu and -march.
486
487 // If we have -mcpu=, use that.
488 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000489 StringRef MCPU = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000490 // Handle -mcpu=native.
491 if (MCPU == "native")
492 return llvm::sys::getHostCPUName();
493 else
494 return MCPU;
495 }
496
497 StringRef MArch;
498 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
499 // Otherwise, if we have -march= choose the base CPU for that arch.
Richard Smithbd55daf2012-11-01 04:30:05 +0000500 MArch = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000501 } else {
502 // Otherwise, use the Arch from the triple.
503 MArch = Triple.getArchName();
504 }
505
506 // Handle -march=native.
507 std::string NativeMArch;
508 if (MArch == "native") {
509 std::string CPU = llvm::sys::getHostCPUName();
510 if (CPU != "generic") {
511 // Translate the native cpu into the architecture. The switch below will
512 // then chose the minimum cpu for that arch.
513 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
514 MArch = NativeMArch;
515 }
516 }
517
518 return llvm::StringSwitch<const char *>(MArch)
519 .Cases("armv2", "armv2a","arm2")
520 .Case("armv3", "arm6")
521 .Case("armv3m", "arm7m")
522 .Cases("armv4", "armv4t", "arm7tdmi")
523 .Cases("armv5", "armv5t", "arm10tdmi")
524 .Cases("armv5e", "armv5te", "arm1022e")
525 .Case("armv5tej", "arm926ej-s")
526 .Cases("armv6", "armv6k", "arm1136jf-s")
527 .Case("armv6j", "arm1136j-s")
528 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
529 .Case("armv6t2", "arm1156t2-s")
530 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000531 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
532 .Cases("armv7s", "armv7-s", "swift")
Benjamin Kramer09811c72012-06-26 22:20:06 +0000533 .Cases("armv7r", "armv7-r", "cortex-r4")
534 .Cases("armv7m", "armv7-m", "cortex-m3")
535 .Case("ep9312", "ep9312")
536 .Case("iwmmxt", "iwmmxt")
537 .Case("xscale", "xscale")
538 .Cases("armv6m", "armv6-m", "cortex-m0")
539 // If all else failed, return the most base CPU LLVM supports.
540 .Default("arm7tdmi");
541}
542
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000543// FIXME: Move to target hook.
544static bool isSignedCharDefault(const llvm::Triple &Triple) {
545 switch (Triple.getArch()) {
546 default:
547 return true;
548
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000549 case llvm::Triple::arm:
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000550 case llvm::Triple::ppc:
551 case llvm::Triple::ppc64:
Bob Wilson6524dd32011-10-14 05:03:44 +0000552 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000553 return true;
554 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000555 }
556}
557
Chad Rosiercfbfc582012-04-04 20:51:35 +0000558// Handle -mfpu=.
559//
560// FIXME: Centralize feature selection, defaulting shouldn't be also in the
561// frontend target.
562static void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args,
563 ArgStringList &CmdArgs) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000564 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000565
566 // Set the target features based on the FPU.
567 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
568 // Disable any default FPU support.
569 CmdArgs.push_back("-target-feature");
570 CmdArgs.push_back("-vfp2");
571 CmdArgs.push_back("-target-feature");
572 CmdArgs.push_back("-vfp3");
573 CmdArgs.push_back("-target-feature");
574 CmdArgs.push_back("-neon");
575 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
576 CmdArgs.push_back("-target-feature");
577 CmdArgs.push_back("+vfp3");
578 CmdArgs.push_back("-target-feature");
579 CmdArgs.push_back("+d16");
580 CmdArgs.push_back("-target-feature");
581 CmdArgs.push_back("-neon");
582 } else if (FPU == "vfp") {
583 CmdArgs.push_back("-target-feature");
584 CmdArgs.push_back("+vfp2");
585 CmdArgs.push_back("-target-feature");
586 CmdArgs.push_back("-neon");
587 } else if (FPU == "vfp3" || FPU == "vfpv3") {
588 CmdArgs.push_back("-target-feature");
589 CmdArgs.push_back("+vfp3");
590 CmdArgs.push_back("-target-feature");
591 CmdArgs.push_back("-neon");
592 } else if (FPU == "neon") {
593 CmdArgs.push_back("-target-feature");
594 CmdArgs.push_back("+neon");
595 } else
596 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
597}
598
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000599// Handle -mfpmath=.
600static void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args,
Chad Rosier45619cb2012-04-04 22:13:40 +0000601 ArgStringList &CmdArgs, StringRef CPU) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000602 StringRef FPMath = A->getValue();
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000603
604 // Set the target features based on the FPMath.
605 if (FPMath == "neon") {
606 CmdArgs.push_back("-target-feature");
607 CmdArgs.push_back("+neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000608
Silviu Baranga157f7c62012-09-13 15:06:00 +0000609 if (CPU != "cortex-a8" && CPU != "cortex-a9" && CPU != "cortex-a9-mp" &&
Quentin Colombet2e9952e2012-11-29 23:15:27 +0000610 CPU != "cortex-a15" && CPU != "cortex-a5")
Chad Rosier45619cb2012-04-04 22:13:40 +0000611 D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU;
612
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000613 } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" ||
614 FPMath == "vfp4") {
615 CmdArgs.push_back("-target-feature");
616 CmdArgs.push_back("-neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000617
618 // FIXME: Add warnings when disabling a feature not present for a given CPU.
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000619 } else
620 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
621}
622
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000623// Select the float ABI as determined by -msoft-float, -mhard-float, and
624// -mfloat-abi=.
625static StringRef getARMFloatABI(const Driver &D,
626 const ArgList &Args,
627 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000628 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000629 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
630 options::OPT_mhard_float,
631 options::OPT_mfloat_abi_EQ)) {
632 if (A->getOption().matches(options::OPT_msoft_float))
633 FloatABI = "soft";
634 else if (A->getOption().matches(options::OPT_mhard_float))
635 FloatABI = "hard";
636 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000637 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000638 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000639 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000640 << A->getAsString(Args);
641 FloatABI = "soft";
642 }
643 }
644 }
645
646 // If unspecified, choose the default based on the platform.
647 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000648 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000649 case llvm::Triple::Darwin:
650 case llvm::Triple::MacOSX:
651 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000652 // Darwin defaults to "softfp" for v6 and v7.
653 //
654 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000655 std::string ArchName =
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000656 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000657 if (StringRef(ArchName).startswith("v6") ||
658 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000659 FloatABI = "softfp";
660 else
661 FloatABI = "soft";
662 break;
663 }
664
665 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000666 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000667 case llvm::Triple::GNUEABIHF:
668 FloatABI = "hard";
669 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000670 case llvm::Triple::GNUEABI:
671 FloatABI = "softfp";
672 break;
673 case llvm::Triple::EABI:
674 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
675 FloatABI = "softfp";
676 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000677 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000678 std::string ArchName =
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000679 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000680 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000681 FloatABI = "softfp";
682 else
683 FloatABI = "soft";
684 break;
685 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000686 default:
687 // Assume "soft", but warn the user we are guessing.
688 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000689 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000690 break;
691 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000692 }
693 }
694
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000695 return FloatABI;
696}
697
698
699void Clang::AddARMTargetArgs(const ArgList &Args,
700 ArgStringList &CmdArgs,
701 bool KernelOrKext) const {
702 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000703 // Get the effective triple, which takes into account the deployment target.
704 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
705 llvm::Triple Triple(TripleStr);
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000706 std::string CPUName = getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000707
708 // Select the ABI to use.
709 //
710 // FIXME: Support -meabi.
711 const char *ABIName = 0;
712 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000713 ABIName = A->getValue();
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000714 } else if (Triple.isOSDarwin()) {
715 // The backend is hardwired to assume AAPCS for M-class processors, ensure
716 // the frontend matches that.
717 if (StringRef(CPUName).startswith("cortex-m")) {
718 ABIName = "aapcs";
719 } else {
720 ABIName = "apcs-gnu";
721 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000722 } else {
723 // Select the default based on the platform.
724 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000725 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000726 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000727 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000728 ABIName = "aapcs-linux";
729 break;
730 case llvm::Triple::EABI:
731 ABIName = "aapcs";
732 break;
733 default:
734 ABIName = "apcs-gnu";
735 }
736 }
737 CmdArgs.push_back("-target-abi");
738 CmdArgs.push_back(ABIName);
739
740 // Set the CPU based on -march= and -mcpu=.
741 CmdArgs.push_back("-target-cpu");
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000742 CmdArgs.push_back(Args.MakeArgString(CPUName));
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000743
744 // Determine floating point ABI from the options & target defaults.
745 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000746 if (FloatABI == "soft") {
747 // Floating point operations and argument passing are soft.
748 //
749 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000750 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000751 CmdArgs.push_back("-mfloat-abi");
752 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000753 } else if (FloatABI == "softfp") {
754 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000755 CmdArgs.push_back("-mfloat-abi");
756 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000757 } else {
758 // Floating point operations and argument passing are hard.
759 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000760 CmdArgs.push_back("-mfloat-abi");
761 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000762 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000763
764 // Set appropriate target features for floating point mode.
765 //
766 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
767 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
768 // stripped out by the ARM target.
769
770 // Use software floating point operations?
771 if (FloatABI == "soft") {
772 CmdArgs.push_back("-target-feature");
773 CmdArgs.push_back("+soft-float");
774 }
775
776 // Use software floating point argument passing?
777 if (FloatABI != "hard") {
778 CmdArgs.push_back("-target-feature");
779 CmdArgs.push_back("+soft-float-abi");
780 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +0000781
782 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +0000783 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +0000784 addFPUArgs(D, A, Args, CmdArgs);
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000785
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000786 // Honor -mfpmath=.
787 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +0000788 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000789
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000790 // Setting -msoft-float effectively disables NEON because of the GCC
791 // implementation, although the same isn't true of VFP or VFP3.
792 if (FloatABI == "soft") {
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000793 CmdArgs.push_back("-target-feature");
794 CmdArgs.push_back("-neon");
795 }
796
797 // Kernel code has more strict alignment requirements.
798 if (KernelOrKext) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000799 if (Triple.getOS() != llvm::Triple::IOS || Triple.isOSVersionLT(6)) {
800 CmdArgs.push_back("-backend-option");
801 CmdArgs.push_back("-arm-long-calls");
802 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000803
Daniel Dunbar12100e22011-03-22 16:48:17 +0000804 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000805 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000806
807 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000808 CmdArgs.push_back("-backend-option");
809 CmdArgs.push_back("-arm-darwin-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000810 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000811
812 // Setting -mno-global-merge disables the codegen global merge pass. Setting
813 // -mglobal-merge has no effect as the pass is enabled by default.
814 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
815 options::OPT_mno_global_merge)) {
816 if (A->getOption().matches(options::OPT_mno_global_merge))
817 CmdArgs.push_back("-mno-global-merge");
818 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000819
Chad Rosierc14ded72012-05-16 21:19:55 +0000820 if (Args.hasArg(options::OPT_mno_implicit_float))
Chad Rosierf1985d22012-05-16 20:40:09 +0000821 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000822}
823
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000824// Translate MIPS CPU name alias option to CPU name.
825static StringRef getMipsCPUFromAlias(const Arg &A) {
826 if (A.getOption().matches(options::OPT_mips32))
827 return "mips32";
828 if (A.getOption().matches(options::OPT_mips32r2))
829 return "mips32r2";
830 if (A.getOption().matches(options::OPT_mips64))
831 return "mips64";
832 if (A.getOption().matches(options::OPT_mips64r2))
833 return "mips64r2";
834 llvm_unreachable("Unexpected option");
835 return "";
836}
837
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000838// Get CPU and ABI names. They are not independent
839// so we have to calculate them together.
840static void getMipsCPUAndABI(const ArgList &Args,
841 const ToolChain &TC,
842 StringRef &CPUName,
843 StringRef &ABIName) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000844 const char *DefMips32CPU = "mips32";
845 const char *DefMips64CPU = "mips64";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000846
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000847 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000848 options::OPT_mcpu_EQ,
849 options::OPT_mips_CPUs_Group)) {
850 if (A->getOption().matches(options::OPT_mips_CPUs_Group))
851 CPUName = getMipsCPUFromAlias(*A);
852 else
Richard Smithbd55daf2012-11-01 04:30:05 +0000853 CPUName = A->getValue();
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000854 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000855
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000856 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000857 ABIName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000858
859 // Setup default CPU and ABI names.
860 if (CPUName.empty() && ABIName.empty()) {
861 switch (TC.getTriple().getArch()) {
862 default:
863 llvm_unreachable("Unexpected triple arch name");
864 case llvm::Triple::mips:
865 case llvm::Triple::mipsel:
866 CPUName = DefMips32CPU;
867 break;
868 case llvm::Triple::mips64:
869 case llvm::Triple::mips64el:
870 CPUName = DefMips64CPU;
871 break;
872 }
873 }
874
875 if (!ABIName.empty()) {
876 // Deduce CPU name from ABI name.
877 CPUName = llvm::StringSwitch<const char *>(ABIName)
878 .Cases("o32", "eabi", DefMips32CPU)
879 .Cases("n32", "n64", DefMips64CPU)
880 .Default("");
881 }
882 else if (!CPUName.empty()) {
883 // Deduce ABI name from CPU name.
884 ABIName = llvm::StringSwitch<const char *>(CPUName)
885 .Cases("mips32", "mips32r2", "o32")
886 .Cases("mips64", "mips64r2", "n64")
887 .Default("");
888 }
889
890 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000891}
892
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000893// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
894// and -mfloat-abi=.
895static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000896 // Select the float ABI as determined by -msoft-float, -mhard-float,
897 // and -mfloat-abi=.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000898 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000899 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000900 options::OPT_mhard_float,
901 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000902 if (A->getOption().matches(options::OPT_msoft_float))
903 FloatABI = "soft";
904 else if (A->getOption().matches(options::OPT_mhard_float))
905 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000906 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000907 FloatABI = A->getValue();
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000908 if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000909 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000910 FloatABI = "hard";
911 }
912 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000913 }
914
915 // If unspecified, choose the default based on the platform.
916 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000917 // Assume "hard", because it's a default value used by gcc.
918 // When we start to recognize specific target MIPS processors,
919 // we will be able to select the default more correctly.
920 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000921 }
922
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000923 return FloatABI;
924}
925
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000926static void AddTargetFeature(const ArgList &Args,
927 ArgStringList &CmdArgs,
928 OptSpecifier OnOpt,
929 OptSpecifier OffOpt,
930 StringRef FeatureName) {
931 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
932 CmdArgs.push_back("-target-feature");
933 if (A->getOption().matches(OnOpt))
934 CmdArgs.push_back(Args.MakeArgString("+" + FeatureName));
935 else
936 CmdArgs.push_back(Args.MakeArgString("-" + FeatureName));
937 }
938}
939
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000940void Clang::AddMIPSTargetArgs(const ArgList &Args,
941 ArgStringList &CmdArgs) const {
942 const Driver &D = getToolChain().getDriver();
943 StringRef CPUName;
944 StringRef ABIName;
945 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
946
947 CmdArgs.push_back("-target-cpu");
948 CmdArgs.push_back(CPUName.data());
949
950 CmdArgs.push_back("-target-abi");
951 CmdArgs.push_back(ABIName.data());
952
953 StringRef FloatABI = getMipsFloatABI(D, Args);
954
Eric Christopher0b26a612010-03-02 02:41:08 +0000955 if (FloatABI == "soft") {
956 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +0000957 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000958 CmdArgs.push_back("-mfloat-abi");
959 CmdArgs.push_back("soft");
960
961 // FIXME: Note, this is a hack. We need to pass the selected float
962 // mode to the MipsTargetInfoBase to define appropriate macros there.
963 // Now it is the only method.
964 CmdArgs.push_back("-target-feature");
965 CmdArgs.push_back("+soft-float");
966 }
967 else if (FloatABI == "single") {
968 // Restrict the use of hardware floating-point
969 // instructions to 32-bit operations.
970 CmdArgs.push_back("-target-feature");
971 CmdArgs.push_back("+single-float");
972 }
973 else {
974 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +0000975 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000976 CmdArgs.push_back("-mfloat-abi");
977 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +0000978 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +0000979
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000980 AddTargetFeature(Args, CmdArgs,
981 options::OPT_mips16, options::OPT_mno_mips16,
982 "mips16");
Simon Atanasyan9c6f1f72012-07-05 19:23:00 +0000983 AddTargetFeature(Args, CmdArgs,
984 options::OPT_mdsp, options::OPT_mno_dsp,
985 "dsp");
986 AddTargetFeature(Args, CmdArgs,
987 options::OPT_mdspr2, options::OPT_mno_dspr2,
988 "dspr2");
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000989
Simon Atanasyan2eaec512012-12-01 18:27:21 +0000990 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
991 if (A->getOption().matches(options::OPT_mxgot)) {
992 CmdArgs.push_back("-mllvm");
993 CmdArgs.push_back("-mxgot");
994 }
995 }
996
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000997 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000998 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000999 CmdArgs.push_back("-mllvm");
1000 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1001 A->claim();
1002 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001003}
1004
Hal Finkel8eb59282012-06-11 22:35:19 +00001005/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1006static std::string getPPCTargetCPU(const ArgList &Args) {
1007 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001008 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001009
1010 if (CPUName == "native") {
1011 std::string CPU = llvm::sys::getHostCPUName();
1012 if (!CPU.empty() && CPU != "generic")
1013 return CPU;
1014 else
1015 return "";
1016 }
1017
1018 return llvm::StringSwitch<const char *>(CPUName)
1019 .Case("common", "generic")
1020 .Case("440", "440")
1021 .Case("440fp", "440")
1022 .Case("450", "450")
1023 .Case("601", "601")
1024 .Case("602", "602")
1025 .Case("603", "603")
1026 .Case("603e", "603e")
1027 .Case("603ev", "603ev")
1028 .Case("604", "604")
1029 .Case("604e", "604e")
1030 .Case("620", "620")
1031 .Case("G3", "g3")
1032 .Case("7400", "7400")
1033 .Case("G4", "g4")
1034 .Case("7450", "7450")
1035 .Case("G4+", "g4+")
1036 .Case("750", "750")
1037 .Case("970", "970")
1038 .Case("G5", "g5")
1039 .Case("a2", "a2")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001040 .Case("e500mc", "e500mc")
1041 .Case("e5500", "e5500")
Hal Finkel8eb59282012-06-11 22:35:19 +00001042 .Case("power6", "pwr6")
1043 .Case("power7", "pwr7")
1044 .Case("powerpc", "ppc")
1045 .Case("powerpc64", "ppc64")
1046 .Default("");
1047 }
1048
1049 return "";
1050}
1051
1052void Clang::AddPPCTargetArgs(const ArgList &Args,
1053 ArgStringList &CmdArgs) const {
1054 std::string TargetCPUName = getPPCTargetCPU(Args);
1055
1056 // LLVM may default to generating code for the native CPU,
1057 // but, like gcc, we default to a more generic option for
1058 // each architecture. (except on Darwin)
1059 llvm::Triple Triple = getToolChain().getTriple();
1060 if (TargetCPUName.empty() && !Triple.isOSDarwin()) {
1061 if (Triple.getArch() == llvm::Triple::ppc64)
1062 TargetCPUName = "ppc64";
1063 else
1064 TargetCPUName = "ppc";
1065 }
1066
1067 if (!TargetCPUName.empty()) {
1068 CmdArgs.push_back("-target-cpu");
1069 CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str()));
1070 }
1071}
1072
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001073void Clang::AddSparcTargetArgs(const ArgList &Args,
1074 ArgStringList &CmdArgs) const {
1075 const Driver &D = getToolChain().getDriver();
1076
1077 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001078 CmdArgs.push_back("-target-cpu");
Richard Smithbd55daf2012-11-01 04:30:05 +00001079 CmdArgs.push_back(A->getValue());
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001080 }
1081
1082 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001083 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001084 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1085 options::OPT_mhard_float)) {
1086 if (A->getOption().matches(options::OPT_msoft_float))
1087 FloatABI = "soft";
1088 else if (A->getOption().matches(options::OPT_mhard_float))
1089 FloatABI = "hard";
1090 }
1091
1092 // If unspecified, choose the default based on the platform.
1093 if (FloatABI.empty()) {
1094 switch (getToolChain().getTriple().getOS()) {
1095 default:
1096 // Assume "soft", but warn the user we are guessing.
1097 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001098 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001099 break;
1100 }
1101 }
1102
1103 if (FloatABI == "soft") {
1104 // Floating point operations and argument passing are soft.
1105 //
1106 // FIXME: This changes CPP defines, we need -target-soft-float.
1107 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001108 CmdArgs.push_back("-target-feature");
1109 CmdArgs.push_back("+soft-float");
1110 } else {
1111 assert(FloatABI == "hard" && "Invalid float abi!");
1112 CmdArgs.push_back("-mhard-float");
1113 }
1114}
1115
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001116void Clang::AddX86TargetArgs(const ArgList &Args,
1117 ArgStringList &CmdArgs) const {
Rafael Espindola7df35012012-11-02 20:41:30 +00001118 const bool isAndroid =
1119 getToolChain().getTriple().getEnvironment() == llvm::Triple::Android;
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001120 if (!Args.hasFlag(options::OPT_mred_zone,
1121 options::OPT_mno_red_zone,
1122 true) ||
1123 Args.hasArg(options::OPT_mkernel) ||
1124 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001125 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001126
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001127 if (Args.hasFlag(options::OPT_msoft_float,
1128 options::OPT_mno_soft_float,
1129 false))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001130 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001131
Daniel Dunbare13ada62009-11-14 22:04:54 +00001132 const char *CPUName = 0;
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001133 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001134 if (StringRef(A->getValue()) == "native") {
Daniel Dunbare13ada62009-11-14 22:04:54 +00001135 // FIXME: Reject attempts to use -march=native unless the target matches
1136 // the host.
1137 //
1138 // FIXME: We should also incorporate the detected target features for use
1139 // with -native.
1140 std::string CPU = llvm::sys::getHostCPUName();
Bob Wilsone78227b2012-05-09 17:53:10 +00001141 if (!CPU.empty() && CPU != "generic")
Daniel Dunbare13ada62009-11-14 22:04:54 +00001142 CPUName = Args.MakeArgString(CPU);
1143 } else
Richard Smithbd55daf2012-11-01 04:30:05 +00001144 CPUName = A->getValue();
Daniel Dunbare13ada62009-11-14 22:04:54 +00001145 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001146
Daniel Dunbare13ada62009-11-14 22:04:54 +00001147 // Select the default CPU if none was given (or detection failed).
1148 if (!CPUName) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001149 // FIXME: Need target hooks.
Bob Wilson6524dd32011-10-14 05:03:44 +00001150 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001151 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbare13ada62009-11-14 22:04:54 +00001152 CPUName = "core2";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001153 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbare13ada62009-11-14 22:04:54 +00001154 CPUName = "yonah";
Chris Lattnerb986aba2010-04-11 19:29:39 +00001155 } else if (getToolChain().getOS().startswith("haiku")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001156 if (getToolChain().getArch() == llvm::Triple::x86_64)
Chris Lattnerb986aba2010-04-11 19:29:39 +00001157 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001158 else if (getToolChain().getArch() == llvm::Triple::x86)
Chris Lattnerb986aba2010-04-11 19:29:39 +00001159 CPUName = "i586";
Daniel Dunbarea3813f2010-08-01 23:13:54 +00001160 } else if (getToolChain().getOS().startswith("openbsd")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001161 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbarea3813f2010-08-01 23:13:54 +00001162 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001163 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarea3813f2010-08-01 23:13:54 +00001164 CPUName = "i486";
Eli Friedman9fa28852012-08-08 23:57:20 +00001165 } else if (getToolChain().getOS().startswith("bitrig")) {
1166 if (getToolChain().getArch() == llvm::Triple::x86_64)
1167 CPUName = "x86-64";
1168 else if (getToolChain().getArch() == llvm::Triple::x86)
1169 CPUName = "i686";
Roman Divacky432f10d2011-03-01 18:11:37 +00001170 } else if (getToolChain().getOS().startswith("freebsd")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001171 if (getToolChain().getArch() == llvm::Triple::x86_64)
Roman Divacky432f10d2011-03-01 18:11:37 +00001172 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001173 else if (getToolChain().getArch() == llvm::Triple::x86)
Roman Divacky432f10d2011-03-01 18:11:37 +00001174 CPUName = "i486";
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001175 } else if (getToolChain().getOS().startswith("netbsd")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001176 if (getToolChain().getArch() == llvm::Triple::x86_64)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001177 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001178 else if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001179 CPUName = "i486";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001180 } else {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001181 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbare13ada62009-11-14 22:04:54 +00001182 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001183 else if (getToolChain().getArch() == llvm::Triple::x86)
Rafael Espindola7df35012012-11-02 20:41:30 +00001184 // All x86 devices running Android have core2 as their common
1185 // denominator. This makes a better choice than pentium4.
1186 CPUName = isAndroid ? "core2" : "pentium4";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001187 }
1188 }
1189
Daniel Dunbare13ada62009-11-14 22:04:54 +00001190 if (CPUName) {
Daniel Dunbara7d02312009-12-18 06:30:12 +00001191 CmdArgs.push_back("-target-cpu");
Daniel Dunbare13ada62009-11-14 22:04:54 +00001192 CmdArgs.push_back(CPUName);
1193 }
1194
Eli Friedmanad811f02011-07-02 00:34:19 +00001195 // The required algorithm here is slightly strange: the options are applied
1196 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
1197 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
1198 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
1199 // former correctly, but not the latter; handle directly-overridden
1200 // attributes here.
1201 llvm::StringMap<unsigned> PrevFeature;
1202 std::vector<const char*> Features;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001203 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1204 ie = Args.filtered_end(); it != ie; ++it) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001205 StringRef Name = (*it)->getOption().getName();
Daniel Dunbara442fd52010-06-11 22:00:13 +00001206 (*it)->claim();
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001207
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001208 // Skip over "-m".
Michael J. Spencer929fccd2012-10-22 22:13:48 +00001209 assert(Name.startswith("m") && "Invalid feature name.");
1210 Name = Name.substr(1);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001211
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001212 bool IsNegative = Name.startswith("no-");
1213 if (IsNegative)
1214 Name = Name.substr(3);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001215
Eli Friedmanad811f02011-07-02 00:34:19 +00001216 unsigned& Prev = PrevFeature[Name];
1217 if (Prev)
1218 Features[Prev - 1] = 0;
1219 Prev = Features.size() + 1;
1220 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1221 }
1222 for (unsigned i = 0; i < Features.size(); i++) {
1223 if (Features[i]) {
1224 CmdArgs.push_back("-target-feature");
1225 CmdArgs.push_back(Features[i]);
1226 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001227 }
1228}
1229
Tony Linthicum76329bf2011-12-12 21:14:55 +00001230static Arg* getLastHexagonArchArg (const ArgList &Args)
1231{
1232 Arg * A = NULL;
1233
Sebastian Pop86500282012-01-13 20:37:10 +00001234 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1235 it != ie; ++it) {
1236 if ((*it)->getOption().matches(options::OPT_march_EQ) ||
Tony Linthicum76329bf2011-12-12 21:14:55 +00001237 (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1238 A = *it;
1239 A->claim();
1240 }
Sebastian Pop86500282012-01-13 20:37:10 +00001241 else if ((*it)->getOption().matches(options::OPT_m_Joined)){
Richard Smithbd55daf2012-11-01 04:30:05 +00001242 StringRef Value = (*it)->getValue(0);
Sebastian Pop86500282012-01-13 20:37:10 +00001243 if (Value.startswith("v")) {
1244 A = *it;
1245 A->claim();
1246 }
1247 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001248 }
1249 return A;
1250}
1251
Sebastian Pop86500282012-01-13 20:37:10 +00001252static StringRef getHexagonTargetCPU(const ArgList &Args)
Tony Linthicum76329bf2011-12-12 21:14:55 +00001253{
1254 Arg *A;
1255 llvm::StringRef WhichHexagon;
1256
Sebastian Pop86500282012-01-13 20:37:10 +00001257 // Select the default CPU (v4) if none was given or detection failed.
Tony Linthicum76329bf2011-12-12 21:14:55 +00001258 if ((A = getLastHexagonArchArg (Args))) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001259 WhichHexagon = A->getValue();
Sebastian Pop86500282012-01-13 20:37:10 +00001260 if (WhichHexagon == "")
1261 return "v4";
1262 else
1263 return WhichHexagon;
Tony Linthicum76329bf2011-12-12 21:14:55 +00001264 }
Sebastian Pop86500282012-01-13 20:37:10 +00001265 else
1266 return "v4";
Tony Linthicum76329bf2011-12-12 21:14:55 +00001267}
1268
1269void Clang::AddHexagonTargetArgs(const ArgList &Args,
1270 ArgStringList &CmdArgs) const {
1271 llvm::Triple Triple = getToolChain().getTriple();
1272
1273 CmdArgs.push_back("-target-cpu");
Sebastian Pop86500282012-01-13 20:37:10 +00001274 CmdArgs.push_back(Args.MakeArgString("hexagon" + getHexagonTargetCPU(Args)));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001275 CmdArgs.push_back("-fno-signed-char");
1276 CmdArgs.push_back("-nobuiltininc");
1277
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001278 if (Args.hasArg(options::OPT_mqdsp6_compat))
Tony Linthicum76329bf2011-12-12 21:14:55 +00001279 CmdArgs.push_back("-mqdsp6-compat");
1280
1281 if (Arg *A = Args.getLastArg(options::OPT_G,
1282 options::OPT_msmall_data_threshold_EQ)) {
1283 std::string SmallDataThreshold="-small-data-threshold=";
Richard Smithbd55daf2012-11-01 04:30:05 +00001284 SmallDataThreshold += A->getValue();
Tony Linthicum76329bf2011-12-12 21:14:55 +00001285 CmdArgs.push_back ("-mllvm");
1286 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
1287 A->claim();
1288 }
1289
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001290 if (!Args.hasArg(options::OPT_fno_short_enums))
1291 CmdArgs.push_back("-fshort-enums");
1292 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1293 CmdArgs.push_back ("-mllvm");
1294 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1295 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001296 CmdArgs.push_back ("-mllvm");
1297 CmdArgs.push_back ("-machine-sink-split=0");
1298}
1299
Eric Christopher84fbdb42011-08-19 00:30:14 +00001300static bool
John McCall5fb5df92012-06-20 06:18:46 +00001301shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001302 const llvm::Triple &Triple) {
1303 // We use the zero-cost exception tables for Objective-C if the non-fragile
1304 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1305 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001306 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001307 return true;
1308
Bob Wilson6524dd32011-10-14 05:03:44 +00001309 if (!Triple.isOSDarwin())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001310 return false;
1311
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001312 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001313 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001314 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001315}
1316
Anders Carlssone96ab552011-02-28 02:27:16 +00001317/// addExceptionArgs - Adds exception related arguments to the driver command
1318/// arguments. There's a master flag, -fexceptions and also language specific
1319/// flags to enable/disable C++ and Objective-C exceptions.
1320/// This makes it possible to for example disable C++ exceptions but enable
1321/// Objective-C exceptions.
1322static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1323 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001324 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001325 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001326 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001327 if (KernelOrKext) {
1328 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1329 // arguments now to avoid warnings about unused arguments.
1330 Args.ClaimAllArgs(options::OPT_fexceptions);
1331 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1332 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1333 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1334 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1335 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001336 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001337 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001338
1339 // Exceptions are enabled by default.
1340 bool ExceptionsEnabled = true;
1341
1342 // This keeps track of whether exceptions were explicitly turned on or off.
1343 bool DidHaveExplicitExceptionFlag = false;
1344
Rafael Espindola00a66572009-10-01 13:33:33 +00001345 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1346 options::OPT_fno_exceptions)) {
1347 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001348 ExceptionsEnabled = true;
Eric Christopher84fbdb42011-08-19 00:30:14 +00001349 else
Anders Carlssone96ab552011-02-28 02:27:16 +00001350 ExceptionsEnabled = false;
1351
1352 DidHaveExplicitExceptionFlag = true;
Rafael Espindola00a66572009-10-01 13:33:33 +00001353 }
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001354
Anders Carlssone96ab552011-02-28 02:27:16 +00001355 bool ShouldUseExceptionTables = false;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +00001356
Anders Carlssone96ab552011-02-28 02:27:16 +00001357 // Exception tables and cleanups can be enabled with -fexceptions even if the
1358 // language itself doesn't support exceptions.
1359 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1360 ShouldUseExceptionTables = true;
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001361
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001362 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1363 // is not necessarily sensible, but follows GCC.
1364 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001365 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001366 options::OPT_fno_objc_exceptions,
1367 true)) {
1368 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001369
Eric Christopher84fbdb42011-08-19 00:30:14 +00001370 ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001371 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001372 }
1373
1374 if (types::isCXX(InputType)) {
1375 bool CXXExceptionsEnabled = ExceptionsEnabled;
1376
Eric Christopher84fbdb42011-08-19 00:30:14 +00001377 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1378 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001379 options::OPT_fexceptions,
1380 options::OPT_fno_exceptions)) {
1381 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1382 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001383 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001384 CXXExceptionsEnabled = false;
1385 }
1386
1387 if (CXXExceptionsEnabled) {
1388 CmdArgs.push_back("-fcxx-exceptions");
1389
1390 ShouldUseExceptionTables = true;
1391 }
1392 }
1393
1394 if (ShouldUseExceptionTables)
1395 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001396}
1397
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001398static bool ShouldDisableCFI(const ArgList &Args,
1399 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001400 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001401 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001402 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001403 // we disable them if we think the .s file will be passed to it.
Rafael Espindolac41db922012-03-08 14:39:55 +00001404 Default = Args.hasFlag(options::OPT_integrated_as,
1405 options::OPT_no_integrated_as,
1406 TC.IsIntegratedAssemblerDefault());
Rafael Espindolaf934f982011-05-17 16:26:17 +00001407 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001408 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1409 options::OPT_fno_dwarf2_cfi_asm,
1410 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001411}
1412
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001413static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1414 const ToolChain &TC) {
1415 bool IsIADefault = TC.IsIntegratedAssemblerDefault();
1416 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1417 options::OPT_no_integrated_as,
1418 IsIADefault);
1419 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1420 options::OPT_fno_dwarf_directory_asm,
1421 UseIntegratedAs);
1422 return !UseDwarfDirectory;
1423}
1424
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001425/// \brief Check whether the given input tree contains any compilation actions.
1426static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001427 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001428 return true;
1429
1430 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1431 if (ContainsCompileAction(*it))
1432 return true;
1433
1434 return false;
1435}
1436
1437/// \brief Check if -relax-all should be passed to the internal assembler.
1438/// This is done by default when compiling non-assembler source with -O0.
1439static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1440 bool RelaxDefault = true;
1441
1442 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1443 RelaxDefault = A->getOption().matches(options::OPT_O0);
1444
1445 if (RelaxDefault) {
1446 RelaxDefault = false;
1447 for (ActionList::const_iterator it = C.getActions().begin(),
1448 ie = C.getActions().end(); it != ie; ++it) {
1449 if (ContainsCompileAction(*it)) {
1450 RelaxDefault = true;
1451 break;
1452 }
1453 }
1454 }
1455
1456 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1457 RelaxDefault);
1458}
1459
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001460SanitizerArgs::SanitizerArgs(const Driver &D, const ArgList &Args) {
1461 Kind = 0;
Richard Smith52be6192012-11-05 22:04:41 +00001462
Richard Smith52be6192012-11-05 22:04:41 +00001463 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
Alexey Samsonov53f7e122012-11-28 17:34:24 +00001464 unsigned Add, Remove;
1465 if (!parse(D, Args, *I, Add, Remove, true))
Richard Smith52be6192012-11-05 22:04:41 +00001466 continue;
Richard Smith52be6192012-11-05 22:04:41 +00001467 (*I)->claim();
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001468 Kind |= Add;
1469 Kind &= ~Remove;
Richard Smith52be6192012-11-05 22:04:41 +00001470 }
1471
1472 // Only one runtime library can be used at once.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001473 bool NeedsAsan = needsAsanRt();
1474 bool NeedsTsan = needsTsanRt();
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001475 bool NeedsMsan = needsMsanRt();
Richard Smith06d87f12012-12-01 01:02:45 +00001476 if (NeedsAsan && NeedsTsan)
Richard Smith52be6192012-11-05 22:04:41 +00001477 D.Diag(diag::err_drv_argument_not_allowed_with)
Richard Smith06d87f12012-12-01 01:02:45 +00001478 << lastArgumentForKind(D, Args, NeedsAsanRt)
1479 << lastArgumentForKind(D, Args, NeedsTsanRt);
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001480 if (NeedsAsan && NeedsMsan)
1481 D.Diag(diag::err_drv_argument_not_allowed_with)
1482 << lastArgumentForKind(D, Args, NeedsAsanRt)
1483 << lastArgumentForKind(D, Args, NeedsMsanRt);
1484 if (NeedsTsan && NeedsMsan)
1485 D.Diag(diag::err_drv_argument_not_allowed_with)
1486 << lastArgumentForKind(D, Args, NeedsTsanRt)
1487 << lastArgumentForKind(D, Args, NeedsMsanRt);
Alexey Samsonov0e96bec2012-11-29 22:36:21 +00001488
1489 // If -fsanitize contains extra features of ASan, it should also
1490 // explicitly contain -fsanitize=address.
1491 if (NeedsAsan && ((Kind & Address) == 0))
1492 D.Diag(diag::err_drv_argument_only_allowed_with)
1493 << lastArgumentForKind(D, Args, NeedsAsanRt)
1494 << "-fsanitize=address";
Alexey Samsonov9ab73622012-12-03 19:12:58 +00001495
1496 // Parse -f(no-)sanitize-blacklist options.
1497 if (Arg *BLArg = Args.getLastArg(options::OPT_fsanitize_blacklist,
1498 options::OPT_fno_sanitize_blacklist)) {
1499 if (BLArg->getOption().matches(options::OPT_fsanitize_blacklist)) {
1500 std::string BLPath = BLArg->getValue();
1501 bool BLExists = false;
1502 if (!llvm::sys::fs::exists(BLPath, BLExists) && BLExists)
1503 BlacklistFile = BLPath;
1504 else
1505 D.Diag(diag::err_drv_no_such_file) << BLPath;
1506 }
1507 }
Richard Smith52be6192012-11-05 22:04:41 +00001508}
1509
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001510/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1511/// This needs to be called before we add the C run-time (malloc, etc).
1512static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00001513 ArgStringList &CmdArgs) {
Logan Chienc6fd8202012-09-02 09:30:11 +00001514 if(TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001515 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovea155f02012-06-04 11:15:05 +00001516 if (!Args.hasArg(options::OPT_pie))
1517 TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001518 }
Daniel Dunbar3ca41d42011-12-07 23:22:17 +00001519
Evgeniy Stepanovcac6aaa2012-09-12 09:09:08 +00001520 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1521 llvm::sys::path::append(LibAsan, "lib", "linux",
1522 (Twine("libclang_rt.asan-") +
1523 TC.getArchName() + "-android.so"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001524 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001525 } else {
1526 if (!Args.hasArg(options::OPT_shared)) {
1527 // LibAsan is "libclang_rt.asan-<ArchName>.a" in the Linux library
1528 // resource directory.
1529 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1530 llvm::sys::path::append(LibAsan, "lib", "linux",
1531 (Twine("libclang_rt.asan-") +
1532 TC.getArchName() + ".a"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001533 // The ASan runtime needs to come before -lstdc++ (or -lc++, libstdc++.a,
1534 // etc.) so that the linker picks ASan's versions of the global 'operator
1535 // new' and 'operator delete' symbols. We take the extreme (but simple)
Chandler Carruth210c77b2012-12-04 22:54:37 +00001536 // strategy of inserting it at the front of the link command. It also
1537 // needs to be forced to end up in the executable, so wrap it in
1538 // whole-archive.
1539 SmallVector<const char*, 3> PrefixArgs;
1540 PrefixArgs.push_back("-whole-archive");
1541 PrefixArgs.push_back(Args.MakeArgString(LibAsan));
1542 PrefixArgs.push_back("-no-whole-archive");
1543 CmdArgs.insert(CmdArgs.begin(), PrefixArgs.begin(), PrefixArgs.end());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001544 CmdArgs.push_back("-lpthread");
1545 CmdArgs.push_back("-ldl");
1546 CmdArgs.push_back("-export-dynamic");
1547 }
1548 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001549}
1550
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001551/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1552/// This needs to be called before we add the C run-time (malloc, etc).
1553static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1554 ArgStringList &CmdArgs) {
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001555 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001556 if (!Args.hasArg(options::OPT_pie))
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001557 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1558 "-fsanitize=thread" << "-pie";
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001559 // LibTsan is "libclang_rt.tsan-<ArchName>.a" in the Linux library
1560 // resource directory.
1561 SmallString<128> LibTsan(TC.getDriver().ResourceDir);
1562 llvm::sys::path::append(LibTsan, "lib", "linux",
1563 (Twine("libclang_rt.tsan-") +
1564 TC.getArchName() + ".a"));
1565 CmdArgs.push_back(Args.MakeArgString(LibTsan));
1566 CmdArgs.push_back("-lpthread");
1567 CmdArgs.push_back("-ldl");
1568 CmdArgs.push_back("-export-dynamic");
1569 }
1570}
1571
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001572/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1573/// This needs to be called before we add the C run-time (malloc, etc).
1574static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1575 ArgStringList &CmdArgs) {
1576 if (!Args.hasArg(options::OPT_shared)) {
1577 if (!Args.hasArg(options::OPT_pie))
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001578 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1579 "-fsanitize=memory" << "-pie";
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001580 // LibMsan is "libclang_rt.msan-<ArchName>.a" in the Linux library
1581 // resource directory.
1582 SmallString<128> LibMsan(TC.getDriver().ResourceDir);
1583 llvm::sys::path::append(LibMsan, "lib", "linux",
1584 (Twine("libclang_rt.msan-") +
1585 TC.getArchName() + ".a"));
1586 CmdArgs.push_back(Args.MakeArgString(LibMsan));
1587 CmdArgs.push_back("-lpthread");
1588 CmdArgs.push_back("-ldl");
1589 CmdArgs.push_back("-export-dynamic");
1590 }
1591}
1592
Richard Smithe30752c2012-10-09 19:52:38 +00001593/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1594/// (Linux).
1595static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1596 ArgStringList &CmdArgs) {
Richard Smithe30752c2012-10-09 19:52:38 +00001597 if (!Args.hasArg(options::OPT_shared)) {
1598 // LibUbsan is "libclang_rt.ubsan-<ArchName>.a" in the Linux library
1599 // resource directory.
1600 SmallString<128> LibUbsan(TC.getDriver().ResourceDir);
1601 llvm::sys::path::append(LibUbsan, "lib", "linux",
1602 (Twine("libclang_rt.ubsan-") +
1603 TC.getArchName() + ".a"));
1604 CmdArgs.push_back(Args.MakeArgString(LibUbsan));
Richard Smith437abed2012-11-02 20:32:19 +00001605 CmdArgs.push_back("-lpthread");
Richard Smith06d87f12012-12-01 01:02:45 +00001606 CmdArgs.push_back("-export-dynamic");
Richard Smithe30752c2012-10-09 19:52:38 +00001607 }
1608}
1609
Rafael Espindola224dd632011-12-14 21:02:23 +00001610static bool shouldUseFramePointer(const ArgList &Args,
1611 const llvm::Triple &Triple) {
1612 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1613 options::OPT_fomit_frame_pointer))
1614 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1615
Rafael Espindola00b29182011-12-14 21:50:24 +00001616 // Don't use a frame pointer on linux x86 and x86_64 if optimizing.
Rafael Espindola224dd632011-12-14 21:02:23 +00001617 if ((Triple.getArch() == llvm::Triple::x86_64 ||
1618 Triple.getArch() == llvm::Triple::x86) &&
1619 Triple.getOS() == llvm::Triple::Linux) {
1620 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1621 if (!A->getOption().matches(options::OPT_O0))
1622 return false;
1623 }
1624
1625 return true;
1626}
1627
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001628void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00001629 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00001630 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001631 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001632 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00001633 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1634 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00001635 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00001636 ArgStringList CmdArgs;
1637
Daniel Dunbare521a892009-03-31 20:53:55 +00001638 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1639
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00001640 // Invoke ourselves in -cc1 mode.
1641 //
1642 // FIXME: Implement custom jobs for internal actions.
1643 CmdArgs.push_back("-cc1");
1644
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001645 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00001646 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00001647 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001648 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00001649
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001650 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00001651 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00001652
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001653 if (isa<AnalyzeJobAction>(JA)) {
1654 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1655 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00001656 } else if (isa<MigrateJobAction>(JA)) {
1657 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001658 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001659 if (Output.getType() == types::TY_Dependencies)
1660 CmdArgs.push_back("-Eonly");
1661 else
1662 CmdArgs.push_back("-E");
Daniel Dunbarc4343942010-02-03 03:07:56 +00001663 } else if (isa<AssembleJobAction>(JA)) {
1664 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001665
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001666 if (UseRelaxAll(C, Args))
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001667 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001668
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001669 // When using an integrated assembler, translate -Wa, and -Xassembler
1670 // options.
1671 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1672 options::OPT_Xassembler),
1673 ie = Args.filtered_end(); it != ie; ++it) {
1674 const Arg *A = *it;
1675 A->claim();
1676
1677 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001678 StringRef Value = A->getValue(i);
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001679
1680 if (Value == "-force_cpusubtype_ALL") {
1681 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbara78e5892010-10-28 20:36:23 +00001682 } else if (Value == "-L") {
Daniel Dunbar67919b22011-03-28 22:49:28 +00001683 CmdArgs.push_back("-msave-temp-labels");
Joerg Sonnenberger3028e462011-05-19 20:46:39 +00001684 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergerb487d2d2011-05-19 18:42:29 +00001685 CmdArgs.push_back("-mllvm");
1686 CmdArgs.push_back("-fatal-assembler-warnings");
Nick Lewyckyca6b90d2011-06-21 00:14:18 +00001687 } else if (Value == "--noexecstack") {
1688 CmdArgs.push_back("-mnoexecstack");
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001689 } else {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001690 D.Diag(diag::err_drv_unsupported_option_argument)
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001691 << A->getOption().getName() << Value;
1692 }
1693 }
1694 }
Daniel Dunbar7c874332010-11-19 16:23:35 +00001695
1696 // Also ignore explicit -force_cpusubtype_ALL option.
1697 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001698 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00001699 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001700 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001701
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001702 if (JA.getType() == types::TY_Nothing)
1703 CmdArgs.push_back("-fsyntax-only");
1704 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00001705 CmdArgs.push_back("-emit-pch");
1706 else
1707 CmdArgs.push_back("-emit-pth");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001708 } else {
1709 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001710
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001711 if (JA.getType() == types::TY_Nothing) {
1712 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001713 } else if (JA.getType() == types::TY_LLVM_IR ||
1714 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001715 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001716 } else if (JA.getType() == types::TY_LLVM_BC ||
1717 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001718 CmdArgs.push_back("-emit-llvm-bc");
1719 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00001720 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001721 } else if (JA.getType() == types::TY_AST) {
1722 CmdArgs.push_back("-emit-pch");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001723 } else if (JA.getType() == types::TY_RewrittenObjC) {
1724 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001725 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00001726 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1727 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001728 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001729 } else {
1730 assert(JA.getType() == types::TY_PP_Asm &&
1731 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001732 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001733 }
1734
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001735 // The make clang go fast button.
1736 CmdArgs.push_back("-disable-free");
1737
John McCallbb79b5f2010-02-13 03:50:24 +00001738 // Disable the verification pass in -asserts builds.
1739#ifdef NDEBUG
1740 CmdArgs.push_back("-disable-llvm-verifier");
1741#endif
1742
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001743 // Set the main file name, so that debug info works even with
1744 // -save-temps.
1745 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00001746 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001747
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001748 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00001749 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001750 if (Args.hasArg(options::OPT_static))
1751 CmdArgs.push_back("-static-define");
1752
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001753 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00001754 // Enable region store model by default.
1755 CmdArgs.push_back("-analyzer-store=region");
1756
Ted Kremenek7bea9a12009-12-07 22:26:14 +00001757 // Treat blocks as analysis entry points.
1758 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1759
Ted Kremenek49c79792011-03-24 00:28:47 +00001760 CmdArgs.push_back("-analyzer-eagerly-assume");
1761
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001762 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001763 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001764 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00001765
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001766 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1767 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00001768
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001769 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00001770 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00001771
1772 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00001773
1774 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00001775 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
1776 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
1777 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
1778 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
1779 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
1780 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001781 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001782
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001783 // Set the output format. The default is plist, for (lame) historical
1784 // reasons.
1785 CmdArgs.push_back("-analyzer-output");
1786 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00001787 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001788 else
1789 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001790
Ted Kremenekfe449a22010-03-22 22:32:05 +00001791 // Disable the presentation of standard compiler warnings when
1792 // using --analyze. We only want to show static analyzer diagnostics
1793 // or frontend errors.
1794 CmdArgs.push_back("-w");
1795
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001796 // Add -Xanalyzer arguments when running as analyzer.
1797 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00001798 }
1799
Daniel Dunbar4eadb602009-09-10 01:21:12 +00001800 CheckCodeGenerationOptions(D, Args);
1801
Chandler Carruth76a943b2012-11-19 03:52:03 +00001802 // For the PIC and PIE flag options, this logic is different from the legacy
1803 // logic in very old versions of GCC, as that logic was just a bug no one had
1804 // ever fixed. This logic is both more rational and consistent with GCC's new
1805 // logic now that the bugs are fixed. The last argument relating to either
1806 // PIC or PIE wins, and no other argument is used. If the last argument is
1807 // any flavor of the '-fno-...' arguments, both PIC and PIE are disabled. Any
1808 // PIE option implicitly enables PIC at the same level.
1809 bool PIE = false;
1810 bool PIC = getToolChain().isPICDefault();
1811 bool IsPICLevelTwo = PIC;
1812 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1813 options::OPT_fpic, options::OPT_fno_pic,
1814 options::OPT_fPIE, options::OPT_fno_PIE,
1815 options::OPT_fpie, options::OPT_fno_pie)) {
1816 Option O = A->getOption();
1817 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1818 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1819 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1820 PIC = PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1821 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
1822 O.matches(options::OPT_fPIC);
1823 } else {
1824 PIE = PIC = false;
1825 }
Benjamin Kramer76db2902012-11-13 15:32:35 +00001826 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00001827 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
1828 // is forced, then neither PIC nor PIE flags will have no effect.
1829 if (getToolChain().isPICDefaultForced()) {
1830 PIE = false;
1831 PIC = getToolChain().isPICDefault();
1832 IsPICLevelTwo = PIC;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001833 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00001834
1835 // Inroduce a Darwin-specific hack. If the default is PIC but the flags
1836 // specified while enabling PIC enabled level 1 PIC, just force it back to
1837 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
1838 // informal testing).
1839 if (PIC && getToolChain().getTriple().isOSDarwin())
1840 IsPICLevelTwo |= getToolChain().isPICDefault();
1841
Chandler Carruthc0c04552012-04-08 16:40:35 +00001842 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
1843 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00001844 llvm::Triple Triple(TripleStr);
1845 if ((Args.hasArg(options::OPT_mkernel) ||
1846 Args.hasArg(options::OPT_fapple_kext)) &&
1847 (Triple.getOS() != llvm::Triple::IOS ||
1848 Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00001849 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001850 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00001851 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001852
Chandler Carruth76a943b2012-11-19 03:52:03 +00001853 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1854 // This is a very special mode. It trumps the other modes, almost no one
1855 // uses it, and it isn't even valid on any OS but Darwin.
1856 if (!getToolChain().getTriple().isOSDarwin())
1857 D.Diag(diag::err_drv_unsupported_opt_for_target)
1858 << A->getSpelling() << getToolChain().getTriple().str();
1859
1860 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
1861
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001862 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00001863 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00001864
Chandler Carruth76a943b2012-11-19 03:52:03 +00001865 // Only a forced PIC mode can cause the actual compile to have PIC defines
1866 // etc., no flags are sufficient. This behavior was selected to closely
1867 // match that of llvm-gcc and Apple GCC before that.
1868 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
1869 CmdArgs.push_back("-pic-level");
1870 CmdArgs.push_back("2");
1871 }
1872 } else {
1873 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
1874 // handled in Clang's IRGen by the -pie-level flag.
1875 CmdArgs.push_back("-mrelocation-model");
1876 CmdArgs.push_back(PIC ? "pic" : "static");
1877
1878 if (PIC) {
1879 CmdArgs.push_back("-pic-level");
1880 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
1881 if (PIE) {
1882 CmdArgs.push_back("-pie-level");
1883 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
1884 }
1885 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00001886 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00001887
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00001888 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1889 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00001890 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00001891
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001892 // LLVM Code Generator Options.
1893
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001894 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1895 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00001896 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001897 }
1898
Roman Divacky65b88cd2011-03-01 17:40:53 +00001899 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1900 CmdArgs.push_back("-mrtd");
1901
Rafael Espindola224dd632011-12-14 21:02:23 +00001902 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001903 CmdArgs.push_back("-mdisable-fp-elim");
1904 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1905 options::OPT_fno_zero_initialized_in_bss))
1906 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Daniel Dunbar7aa71f92011-02-04 02:20:39 +00001907 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1908 options::OPT_fno_strict_aliasing,
1909 getToolChain().IsStrictAliasingDefault()))
Dan Gohman10169b92010-10-14 22:36:56 +00001910 CmdArgs.push_back("-relaxed-aliasing");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00001911 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
1912 false))
1913 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00001914 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
1915 options::OPT_fno_optimize_sibling_calls))
1916 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00001917
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001918 // Handle various floating point optimization flags, mapping them to the
1919 // appropriate LLVM code generation flags. The pattern for all of these is to
1920 // default off the codegen optimizations, and if any flag enables them and no
1921 // flag disables them after the flag enabling them, enable the codegen
1922 // optimization. This is complicated by several "umbrella" flags.
1923 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001924 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001925 options::OPT_ffinite_math_only,
1926 options::OPT_fno_finite_math_only,
1927 options::OPT_fhonor_infinities,
1928 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001929 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1930 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001931 A->getOption().getID() != options::OPT_fhonor_infinities)
1932 CmdArgs.push_back("-menable-no-infs");
1933 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001934 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001935 options::OPT_ffinite_math_only,
1936 options::OPT_fno_finite_math_only,
1937 options::OPT_fhonor_nans,
1938 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001939 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1940 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001941 A->getOption().getID() != options::OPT_fhonor_nans)
1942 CmdArgs.push_back("-menable-no-nans");
1943
Benjamin Kramerc242ef22012-05-02 14:55:48 +00001944 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
1945 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001946 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001947 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001948 options::OPT_fmath_errno,
Chandler Carruth3634c662012-04-26 02:10:51 +00001949 options::OPT_fno_math_errno))
1950 MathErrno = A->getOption().getID() == options::OPT_fmath_errno;
1951 if (MathErrno)
1952 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001953
1954 // There are several flags which require disabling very specific
1955 // optimizations. Any of these being disabled forces us to turn off the
1956 // entire set of LLVM optimizations, so collect them through all the flag
1957 // madness.
1958 bool AssociativeMath = false;
1959 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001960 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001961 options::OPT_funsafe_math_optimizations,
1962 options::OPT_fno_unsafe_math_optimizations,
1963 options::OPT_fassociative_math,
1964 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001965 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1966 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001967 A->getOption().getID() != options::OPT_fno_associative_math)
1968 AssociativeMath = true;
1969 bool ReciprocalMath = false;
1970 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001971 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001972 options::OPT_funsafe_math_optimizations,
1973 options::OPT_fno_unsafe_math_optimizations,
1974 options::OPT_freciprocal_math,
1975 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001976 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1977 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001978 A->getOption().getID() != options::OPT_fno_reciprocal_math)
1979 ReciprocalMath = true;
1980 bool SignedZeros = true;
1981 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001982 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001983 options::OPT_funsafe_math_optimizations,
1984 options::OPT_fno_unsafe_math_optimizations,
1985 options::OPT_fsigned_zeros,
1986 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001987 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1988 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001989 A->getOption().getID() != options::OPT_fsigned_zeros)
1990 SignedZeros = false;
1991 bool TrappingMath = true;
1992 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001993 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001994 options::OPT_funsafe_math_optimizations,
1995 options::OPT_fno_unsafe_math_optimizations,
1996 options::OPT_ftrapping_math,
1997 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001998 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1999 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002000 A->getOption().getID() != options::OPT_ftrapping_math)
2001 TrappingMath = false;
2002 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2003 !TrappingMath)
2004 CmdArgs.push_back("-menable-unsafe-fp-math");
2005
Lang Hamesaa53b932012-07-06 00:59:19 +00002006
2007 // Validate and pass through -fp-contract option.
2008 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002009 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002010 options::OPT_ffp_contract)) {
2011 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002012 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002013 if (Val == "fast" || Val == "on" || Val == "off") {
2014 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2015 } else {
2016 D.Diag(diag::err_drv_unsupported_option_argument)
2017 << A->getOption().getName() << Val;
2018 }
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002019 } else if (A->getOption().getID() == options::OPT_ffast_math) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002020 // If fast-math is set then set the fp-contract mode to fast.
2021 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2022 }
2023 }
2024
Bob Wilson6a039162012-07-19 03:52:53 +00002025 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2026 // and if we find them, tell the frontend to provide the appropriate
2027 // preprocessor macros. This is distinct from enabling any optimizations as
2028 // these options induce language changes which must survive serialization
2029 // and deserialization, etc.
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002030 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math))
2031 if (A->getOption().matches(options::OPT_ffast_math))
2032 CmdArgs.push_back("-ffast-math");
2033 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2034 if (A->getOption().matches(options::OPT_ffinite_math_only))
2035 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002036
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002037 // Decide whether to use verbose asm. Verbose assembly is the default on
2038 // toolchains which have the integrated assembler on by default.
2039 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2040 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002041 IsVerboseAsmDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002042 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002043 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002044
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002045 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2046 CmdArgs.push_back("-mdebug-pass");
2047 CmdArgs.push_back("Structure");
2048 }
2049 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2050 CmdArgs.push_back("-mdebug-pass");
2051 CmdArgs.push_back("Arguments");
2052 }
2053
John McCall8517abc2010-02-19 02:45:38 +00002054 // Enable -mconstructor-aliases except on darwin, where we have to
2055 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002056 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002057 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002058
John McCall7ef5cb32011-03-18 02:56:14 +00002059 // Darwin's kernel doesn't support guard variables; just die if we
2060 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002061 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002062 CmdArgs.push_back("-fforbid-guard-variables");
2063
Douglas Gregordbe39272011-02-01 15:15:22 +00002064 if (Args.hasArg(options::OPT_mms_bitfields)) {
2065 CmdArgs.push_back("-mms-bitfields");
2066 }
John McCall8517abc2010-02-19 02:45:38 +00002067
Daniel Dunbar306945d2009-09-16 06:17:29 +00002068 // This is a coarse approximation of what llvm-gcc actually does, both
2069 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2070 // complicated ways.
2071 bool AsynchronousUnwindTables =
2072 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2073 options::OPT_fno_asynchronous_unwind_tables,
2074 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002075 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002076 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2077 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002078 CmdArgs.push_back("-munwind-tables");
2079
Chandler Carruth05fb5852012-11-21 23:40:23 +00002080 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002081
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002082 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2083 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002084 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002085 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002086
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002087 // FIXME: Handle -mtune=.
2088 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002089
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002090 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002091 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002092 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002093 }
2094
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002095 // Add target specific cpu and features flags.
2096 switch(getToolChain().getTriple().getArch()) {
2097 default:
2098 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002099
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002100 case llvm::Triple::arm:
2101 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002102 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002103 break;
2104
Eric Christopher0b26a612010-03-02 02:41:08 +00002105 case llvm::Triple::mips:
2106 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002107 case llvm::Triple::mips64:
2108 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002109 AddMIPSTargetArgs(Args, CmdArgs);
2110 break;
2111
Hal Finkel8eb59282012-06-11 22:35:19 +00002112 case llvm::Triple::ppc:
2113 case llvm::Triple::ppc64:
2114 AddPPCTargetArgs(Args, CmdArgs);
2115 break;
2116
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002117 case llvm::Triple::sparc:
2118 AddSparcTargetArgs(Args, CmdArgs);
2119 break;
2120
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002121 case llvm::Triple::x86:
2122 case llvm::Triple::x86_64:
2123 AddX86TargetArgs(Args, CmdArgs);
2124 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002125
2126 case llvm::Triple::hexagon:
2127 AddHexagonTargetArgs(Args, CmdArgs);
2128 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002129 }
2130
Tony Linthicum76329bf2011-12-12 21:14:55 +00002131
2132
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002133 // Pass the linker version in use.
2134 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2135 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002136 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002137 }
2138
Nick Lewycky75033772011-02-02 06:43:03 +00002139 // -mno-omit-leaf-frame-pointer is the default on Darwin.
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002140 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
Nick Lewycky75033772011-02-02 06:43:03 +00002141 options::OPT_mno_omit_leaf_frame_pointer,
Bob Wilson6524dd32011-10-14 05:03:44 +00002142 !getToolChain().getTriple().isOSDarwin()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002143 CmdArgs.push_back("-momit-leaf-frame-pointer");
2144
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002145 // Explicitly error on some things we know we don't support and can't just
2146 // ignore.
2147 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002148 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2149 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002150 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002151 getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002152 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002153 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2154 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002155 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002156 << Unsupported->getOption().getName();
2157 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002158 }
2159
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002160 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002161 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002162 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002163 CmdArgs.push_back("-header-include-file");
2164 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2165 D.CCPrintHeadersFilename : "-");
2166 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002167 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002168 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002169
Chad Rosierbe10f982011-08-02 17:58:04 +00002170 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002171 CmdArgs.push_back("-diagnostic-log-file");
2172 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2173 D.CCLogDiagnosticsFilename : "-");
2174 }
2175
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002176 // Use the last option from "-g" group. "-gline-tables-only" is
2177 // preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002178 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002179 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2180 if (A->getOption().matches(options::OPT_gline_tables_only)) {
2181 CmdArgs.push_back("-gline-tables-only");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002182 } else if (!A->getOption().matches(options::OPT_g0) &&
2183 !A->getOption().matches(options::OPT_ggdb0)) {
Chad Rosier8fe3b112011-11-07 19:52:29 +00002184 CmdArgs.push_back("-g");
Chad Rosierc2bf3382011-11-04 19:28:44 +00002185 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002186 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002187
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002188 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2189 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002190 if (Args.hasArg(options::OPT_gcolumn_info))
2191 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002192
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002193 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2194 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2195
Chris Lattner3c77a352010-06-22 00:03:40 +00002196 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2197
Nick Lewycky207bce32011-04-21 23:44:07 +00002198 if (Args.hasArg(options::OPT_ftest_coverage) ||
2199 Args.hasArg(options::OPT_coverage))
2200 CmdArgs.push_back("-femit-coverage-notes");
2201 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2202 Args.hasArg(options::OPT_coverage))
2203 CmdArgs.push_back("-femit-coverage-data");
2204
Nick Lewycky480cb992011-05-04 20:46:58 +00002205 if (C.getArgs().hasArg(options::OPT_c) ||
2206 C.getArgs().hasArg(options::OPT_S)) {
2207 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002208 CmdArgs.push_back("-coverage-file");
Bill Wendling8c0b4bc2012-08-30 00:43:41 +00002209 SmallString<128> absFilename(Output.getFilename());
2210 llvm::sys::fs::make_absolute(absFilename);
2211 CmdArgs.push_back(Args.MakeArgString(absFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002212 }
2213 }
2214
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002215 // Pass options for controlling the default header search paths.
2216 if (Args.hasArg(options::OPT_nostdinc)) {
2217 CmdArgs.push_back("-nostdsysteminc");
2218 CmdArgs.push_back("-nobuiltininc");
2219 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002220 if (Args.hasArg(options::OPT_nostdlibinc))
2221 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002222 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2223 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2224 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002225
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002226 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002227 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002228 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002229
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002230 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2231
Ted Kremenekf7639e12012-03-06 20:06:33 +00002232 bool ARCMTEnabled = false;
John McCalld70fb982011-06-15 23:25:17 +00002233 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002234 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002235 options::OPT_ccc_arcmt_modify,
2236 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002237 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002238 switch (A->getOption().getID()) {
2239 default:
2240 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002241 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002242 CmdArgs.push_back("-arcmt-check");
2243 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002244 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002245 CmdArgs.push_back("-arcmt-modify");
2246 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002247 case options::OPT_ccc_arcmt_migrate:
2248 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002249 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002250 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002251
2252 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2253 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002254 break;
John McCalld70fb982011-06-15 23:25:17 +00002255 }
2256 }
2257 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002258
Ted Kremenekf7639e12012-03-06 20:06:33 +00002259 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2260 if (ARCMTEnabled) {
2261 D.Diag(diag::err_drv_argument_not_allowed_with)
2262 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2263 }
2264 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002265 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002266
2267 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2268 options::OPT_objcmt_migrate_subscripting)) {
2269 // None specified, means enable them all.
2270 CmdArgs.push_back("-objcmt-migrate-literals");
2271 CmdArgs.push_back("-objcmt-migrate-subscripting");
2272 } else {
2273 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2274 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2275 }
2276 }
2277
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002278 // Add preprocessing options like -I, -D, etc. if we are using the
2279 // preprocessor.
2280 //
2281 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002282 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Peter Collingbourne9b515cb2011-11-06 00:40:05 +00002283 AddPreprocessingOptions(C, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002284
Rafael Espindolaa7431922011-07-21 23:40:37 +00002285 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2286 // that "The compiler can only warn and ignore the option if not recognized".
2287 // When building with ccache, it will pass -D options to clang even on
2288 // preprocessed inputs and configure concludes that -fPIC is not supported.
2289 Args.ClaimAllArgs(options::OPT_D);
2290
Daniel Dunbar58f78332009-09-17 06:53:36 +00002291 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar13864952009-03-24 20:17:30 +00002292 // others.
2293 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00002294 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar13864952009-03-24 20:17:30 +00002295 CmdArgs.push_back("-O3");
Daniel Dunbar9296f632010-05-27 06:51:08 +00002296 else if (A->getOption().matches(options::OPT_O) &&
Richard Smithbd55daf2012-11-01 04:30:05 +00002297 A->getValue()[0] == '\0')
Daniel Dunbar58f78332009-09-17 06:53:36 +00002298 CmdArgs.push_back("-O2");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002299 else
Daniel Dunbar7ef5ed62009-03-18 23:39:35 +00002300 A->render(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002301 }
2302
Daniel Dunbar945577c2009-10-29 02:24:45 +00002303 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002304 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2305 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002306 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002307 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002308
2309 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2310 // (-ansi is equivalent to -std=c89).
2311 //
2312 // If a std is supplied, only add -trigraphs if it follows the
2313 // option.
2314 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2315 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002316 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002317 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002318 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002319 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002320 else
2321 Std->render(Args, CmdArgs);
2322
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002323 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2324 options::OPT_trigraphs))
2325 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002326 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002327 } else {
2328 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002329 //
2330 // FIXME: Clang doesn't correctly handle -std= when the input language
2331 // doesn't match. For the time being just ignore this for C++ inputs;
2332 // eventually we want to do all the standard defaulting here instead of
2333 // splitting it between the driver and clang -cc1.
2334 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002335 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2336 "-std=", /*Joined=*/true);
2337 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2338 CmdArgs.push_back("-std=c++11");
2339
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002340 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002341 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002342
Chandler Carruthb009b142011-04-23 06:30:43 +00002343 // Map the bizarre '-Wwrite-strings' flag to a more sensible
2344 // '-fconst-strings'; this better indicates its actual behavior.
2345 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
2346 false)) {
2347 // For perfect compatibility with GCC, we do this even in the presence of
2348 // '-w'. This flag names something other than a warning for GCC.
2349 CmdArgs.push_back("-fconst-strings");
2350 }
2351
Chandler Carruth61fbf622011-04-23 09:27:53 +00002352 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002353 // during C++ compilation, which it is by default. GCC keeps this define even
2354 // in the presence of '-w', match this behavior bug-for-bug.
2355 if (types::isCXX(InputType) &&
2356 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2357 true)) {
2358 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002359 }
2360
Chandler Carruthe0391482010-05-22 02:21:53 +00002361 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2362 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2363 if (Asm->getOption().matches(options::OPT_fasm))
2364 CmdArgs.push_back("-fgnu-keywords");
2365 else
2366 CmdArgs.push_back("-fno-gnu-keywords");
2367 }
2368
Rafael Espindola4cfa7972011-05-02 17:43:32 +00002369 if (ShouldDisableCFI(Args, getToolChain()))
2370 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00002371
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002372 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2373 CmdArgs.push_back("-fno-dwarf-directory-asm");
2374
Nick Lewyckyba743b72011-10-21 02:32:14 +00002375 if (const char *pwd = ::getenv("PWD")) {
2376 // GCC also verifies that stat(pwd) and stat(".") have the same inode
2377 // number. Not doing those because stats are slow, but we could.
NAKAMURA Takumib5e6fa22011-10-22 10:25:25 +00002378 if (llvm::sys::path::is_absolute(pwd)) {
Nick Lewyckyba743b72011-10-21 02:32:14 +00002379 std::string CompDir = pwd;
2380 CmdArgs.push_back("-fdebug-compilation-dir");
2381 CmdArgs.push_back(Args.MakeArgString(CompDir));
2382 }
2383 }
2384
Richard Smith9a568822011-11-21 19:36:32 +00002385 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2386 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002387 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002388 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002389 }
2390
Richard Smith9a568822011-11-21 19:36:32 +00002391 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2392 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002393 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00002394 }
2395
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00002396 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2397 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002398 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002399 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002400 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2401 } else
2402 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00002403 }
2404
Nuno Lopes3d6311d2012-05-08 22:10:46 +00002405
Michael J. Spencer929fccd2012-10-22 22:13:48 +00002406 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002407 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00002408
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002409 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2410 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00002411 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002412 }
David Chisnall5778fce2009-08-31 16:41:57 +00002413
Chris Lattnere23003d2010-01-09 21:54:33 +00002414 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2415 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00002416 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00002417 }
2418
Chris Lattnerb35583d2010-04-07 20:49:23 +00002419 CmdArgs.push_back("-ferror-limit");
2420 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00002421 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00002422 else
2423 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00002424
Chandler Carrutha77a7272010-05-06 04:55:18 +00002425 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2426 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002427 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002428 }
2429
2430 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2431 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002432 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002433 }
2434
Richard Smithf6f003a2011-12-16 19:06:07 +00002435 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2436 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002437 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00002438 }
2439
Daniel Dunbar2c978472009-11-04 06:24:47 +00002440 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00002441 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00002442 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002443 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00002444 } else {
2445 // If -fmessage-length=N was not specified, determine whether this is a
2446 // terminal and, if so, implicitly define -fmessage-length appropriately.
2447 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002448 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00002449 }
2450
Daniel Dunbare357d562009-12-03 18:42:11 +00002451 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
2452 CmdArgs.push_back("-fvisibility");
Richard Smithbd55daf2012-11-01 04:30:05 +00002453 CmdArgs.push_back(A->getValue());
Daniel Dunbare357d562009-12-03 18:42:11 +00002454 }
2455
Douglas Gregor08329632010-06-15 17:05:35 +00002456 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002457
Hans Wennborgf60f6af2012-06-28 08:01:44 +00002458 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2459
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002460 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002461 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2462 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002463 CmdArgs.push_back("-ffreestanding");
2464
Daniel Dunbare357d562009-12-03 18:42:11 +00002465 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002466 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002467 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patel91bbb552010-09-30 19:05:55 +00002468 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Devang Patel384dfa42011-11-04 20:05:58 +00002469 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
Eric Christopher86050822011-10-25 07:13:06 +00002470 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Anton Yartsev9b6b2e52011-12-23 20:23:19 +00002471 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00002472 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2473 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00002474
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002475 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00002476 Sanitize.addArgs(Args, CmdArgs);
2477
Chad Rosier864dfe12012-03-13 23:45:51 +00002478 // Report and error for -faltivec on anything other then PowerPC.
2479 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
2480 if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc ||
2481 getToolChain().getTriple().getArch() == llvm::Triple::ppc64))
2482 D.Diag(diag::err_drv_argument_only_allowed_with)
2483 << A->getAsString(Args) << "ppc/ppc64";
2484
Daniel Dunbar733b0f82011-03-01 18:49:30 +00002485 if (getToolChain().SupportsProfiling())
2486 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00002487
2488 // -flax-vector-conversions is default.
2489 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2490 options::OPT_fno_lax_vector_conversions))
2491 CmdArgs.push_back("-fno-lax-vector-conversions");
2492
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002493 if (Args.getLastArg(options::OPT_fapple_kext))
2494 CmdArgs.push_back("-fapple-kext");
2495
David Blaikie690f21e2012-06-14 18:55:27 +00002496 if (Args.hasFlag(options::OPT_frewrite_includes,
2497 options::OPT_fno_rewrite_includes, false))
2498 CmdArgs.push_back("-frewrite-includes");
2499
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00002500 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00002501 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00002502 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002503 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2504 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00002505
2506 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2507 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00002508 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00002509 }
2510
Bob Wilson14adb362012-02-03 06:27:22 +00002511 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00002512
Chandler Carruth6e501032011-03-27 00:04:55 +00002513 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2514 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2515 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2516 options::OPT_fno_wrapv)) {
2517 if (A->getOption().matches(options::OPT_fwrapv))
2518 CmdArgs.push_back("-fwrapv");
2519 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2520 options::OPT_fno_strict_overflow)) {
2521 if (A->getOption().matches(options::OPT_fno_strict_overflow))
2522 CmdArgs.push_back("-fwrapv");
2523 }
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002524 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf387dbd2010-08-07 23:08:14 +00002525 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002526
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00002527 Args.AddLastArg(CmdArgs, options::OPT_pthread);
2528
Mahesha S6a682be42012-10-27 07:47:56 +00002529
Daniel Dunbar4930e332009-11-17 08:07:36 +00002530 // -stack-protector=0 is default.
2531 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002532 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2533 options::OPT_fstack_protector_all,
2534 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002535 if (A->getOption().matches(options::OPT_fstack_protector))
2536 StackProtectorLevel = 1;
2537 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2538 StackProtectorLevel = 2;
Nico Weberdd473632011-08-23 07:38:27 +00002539 } else {
2540 StackProtectorLevel =
2541 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2542 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002543 if (StackProtectorLevel) {
2544 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002545 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002546 }
Chad Rosierdb3da832012-08-21 16:16:06 +00002547
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002548 // --param ssp-buffer-size=
2549 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
2550 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002551 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002552 if (Str.startswith("ssp-buffer-size=")) {
2553 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00002554 CmdArgs.push_back("-stack-protector-buffer-size");
2555 // FIXME: Verify the argument is a valid integer.
2556 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00002557 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002558 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00002559 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002560 }
2561
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00002562 // Translate -mstackrealign
2563 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2564 false)) {
2565 CmdArgs.push_back("-backend-option");
2566 CmdArgs.push_back("-force-align-stack");
2567 }
2568 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2569 false)) {
2570 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2571 }
2572
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00002573 if (Args.hasArg(options::OPT_mstack_alignment)) {
2574 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2575 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00002576 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00002577 // -mkernel implies -mstrict-align; don't add the redundant option.
2578 if (Args.hasArg(options::OPT_mstrict_align) && !KernelOrKext) {
Chad Rosierd87e4f72012-11-09 18:27:01 +00002579 CmdArgs.push_back("-backend-option");
2580 CmdArgs.push_back("-arm-strict-align");
Chad Rosier60027022012-11-09 17:29:19 +00002581 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002582
Daniel Dunbard18049a2009-04-07 21:16:11 +00002583 // Forward -f options with positive and negative forms; we translate
2584 // these by hand.
2585
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002586 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00002587 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002588 CmdArgs.push_back("-fapple-kext");
2589 if (!Args.hasArg(options::OPT_fbuiltin))
2590 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00002591 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002592 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002593 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002594 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00002595 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00002596
Nuno Lopes13c88c72009-12-16 16:59:22 +00002597 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2598 options::OPT_fno_assume_sane_operator_new))
2599 CmdArgs.push_back("-fno-assume-sane-operator-new");
2600
Daniel Dunbar4930e332009-11-17 08:07:36 +00002601 // -fblocks=0 is default.
2602 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00002603 getToolChain().IsBlocksDefault()) ||
2604 (Args.hasArg(options::OPT_fgnu_runtime) &&
2605 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
2606 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002607 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00002608
2609 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
2610 !getToolChain().hasBlocksRuntime())
2611 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00002612 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00002613
Douglas Gregor226173a2012-01-18 15:19:58 +00002614 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
2615 // users must also pass -fcxx-modules. The latter flag will disappear once the
2616 // modules implementation is solid for C++/Objective-C++ programs as well.
2617 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
2618 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2619 options::OPT_fno_cxx_modules,
2620 false);
2621 if (AllowedInCXX || !types::isCXX(InputType))
2622 CmdArgs.push_back("-fmodules");
2623 }
Douglas Gregor787869b2012-01-03 17:13:05 +00002624
John McCalldfea9982010-04-09 19:12:06 +00002625 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00002626 if (Args.hasFlag(options::OPT_fno_access_control,
2627 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00002628 false))
John McCall3155f572010-04-09 19:03:51 +00002629 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00002630
Anders Carlssond470fef2010-11-21 00:09:52 +00002631 // -felide-constructors is the default.
2632 if (Args.hasFlag(options::OPT_fno_elide_constructors,
2633 options::OPT_felide_constructors,
2634 false))
2635 CmdArgs.push_back("-fno-elide-constructors");
2636
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002637 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002638 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00002639 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00002640 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00002641
Richard Smith52be6192012-11-05 22:04:41 +00002642 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002643 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00002644 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00002645 Args.getLastArg(options::OPT_mkernel,
2646 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00002647 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00002648 D.Diag(diag::err_drv_argument_not_allowed_with)
2649 << "-fsanitize=vptr" << NoRttiArg;
2650 }
2651 }
2652
Tony Linthicum76329bf2011-12-12 21:14:55 +00002653 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002654 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00002655 options::OPT_fno_short_enums,
2656 getToolChain().getTriple().getArch() ==
2657 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002658 CmdArgs.push_back("-fshort-enums");
2659
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002660 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002661 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002662 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00002663 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00002664
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002665 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002666 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002667 options::OPT_fno_threadsafe_statics))
2668 CmdArgs.push_back("-fno-threadsafe-statics");
2669
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002670 // -fuse-cxa-atexit is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002671 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
2672 options::OPT_fno_use_cxa_atexit,
2673 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
Tony Linthicum76329bf2011-12-12 21:14:55 +00002674 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Chad Rosier4fab82c2012-03-26 22:04:46 +00002675 getToolChain().getTriple().getArch() != llvm::Triple::hexagon) ||
2676 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002677 CmdArgs.push_back("-fno-use-cxa-atexit");
2678
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002679 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002680 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002681 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2682 CmdArgs.push_back("-fms-extensions");
2683
Chad Rosiered943242012-07-20 21:20:33 +00002684 // -fms-inline-asm.
Chad Rosierd3957e52012-07-20 23:12:26 +00002685 if (Args.hasArg(options::OPT_fenable_experimental_ms_inline_asm))
2686 CmdArgs.push_back("-fenable-experimental-ms-inline-asm");
Chad Rosiered943242012-07-20 21:20:33 +00002687
Francois Pichet1b4f1632011-09-17 04:32:15 +00002688 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00002689 if (Args.hasFlag(options::OPT_fms_compatibility,
2690 options::OPT_fno_ms_compatibility,
2691 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
2692 Args.hasFlag(options::OPT_fms_extensions,
2693 options::OPT_fno_ms_extensions,
2694 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00002695 CmdArgs.push_back("-fms-compatibility");
2696
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002697 // -fmsc-version=1300 is default.
2698 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2699 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
2700 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002701 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002702 if (msc_ver.empty())
2703 CmdArgs.push_back("-fmsc-version=1300");
2704 else
2705 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
2706 }
2707
2708
Dawn Perchik68bb1b42010-09-02 23:59:25 +00002709 // -fborland-extensions=0 is default.
2710 if (Args.hasFlag(options::OPT_fborland_extensions,
2711 options::OPT_fno_borland_extensions, false))
2712 CmdArgs.push_back("-fborland-extensions");
2713
Francois Pichet02744872011-09-01 16:38:08 +00002714 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
2715 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00002716 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
2717 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00002718 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00002719 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00002720
Chandler Carruthe03aa552010-04-17 20:17:31 +00002721 // -fgnu-keywords default varies depending on language; only pass if
2722 // specified.
2723 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00002724 options::OPT_fno_gnu_keywords))
2725 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00002726
Rafael Espindola922a6242011-06-02 17:30:53 +00002727 if (Args.hasFlag(options::OPT_fgnu89_inline,
2728 options::OPT_fno_gnu89_inline,
2729 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00002730 CmdArgs.push_back("-fgnu89-inline");
2731
Chad Rosier9c76d242012-03-15 22:31:42 +00002732 if (Args.hasArg(options::OPT_fno_inline))
2733 CmdArgs.push_back("-fno-inline");
2734
Chad Rosier64d6be92012-03-06 21:17:19 +00002735 if (Args.hasArg(options::OPT_fno_inline_functions))
2736 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00002737
John McCall5fb5df92012-06-20 06:18:46 +00002738 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00002739
John McCall5fb5df92012-06-20 06:18:46 +00002740 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
2741 // legacy is the default.
2742 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00002743 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2744 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00002745 objcRuntime.isLegacyDispatchDefaultForArch(
2746 getToolChain().getTriple().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00002747 if (getToolChain().UseObjCMixedDispatch())
2748 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
2749 else
2750 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
2751 }
2752 }
2753
Nico Weber97bd94b2012-03-09 21:19:44 +00002754 // -fobjc-default-synthesize-properties=1 is default. This only has an effect
2755 // if the nonfragile objc abi is used.
Fariborz Jahanian05684072012-04-09 18:58:55 +00002756 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
David Chisnall3154e682011-09-30 13:32:35 +00002757 CmdArgs.push_back("-fobjc-default-synthesize-properties");
2758 }
2759
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00002760 // -fencode-extended-block-signature=1 is default.
2761 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
2762 CmdArgs.push_back("-fencode-extended-block-signature");
2763 }
2764
John McCall24fc0de2011-07-06 00:26:06 +00002765 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
2766 // NOTE: This logic is duplicated in ToolChains.cpp.
2767 bool ARC = isObjCAutoRefCount(Args);
2768 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00002769 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00002770
John McCall24fc0de2011-07-06 00:26:06 +00002771 CmdArgs.push_back("-fobjc-arc");
2772
Chandler Carruth491db322011-11-04 07:34:47 +00002773 // FIXME: It seems like this entire block, and several around it should be
2774 // wrapped in isObjC, but for now we just use it here as this is where it
2775 // was being used previously.
2776 if (types::isCXX(InputType) && types::isObjC(InputType)) {
2777 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2778 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
2779 else
2780 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
2781 }
2782
John McCall24fc0de2011-07-06 00:26:06 +00002783 // Allow the user to enable full exceptions code emission.
2784 // We define off for Objective-CC, on for Objective-C++.
2785 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2786 options::OPT_fno_objc_arc_exceptions,
2787 /*default*/ types::isCXX(InputType)))
2788 CmdArgs.push_back("-fobjc-arc-exceptions");
2789 }
2790
2791 // -fobjc-infer-related-result-type is the default, except in the Objective-C
2792 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00002793 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00002794 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002795
John McCall24fc0de2011-07-06 00:26:06 +00002796 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
2797 // takes precedence.
2798 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
2799 if (!GCArg)
2800 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
2801 if (GCArg) {
2802 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002803 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00002804 << GCArg->getAsString(Args);
2805 } else if (getToolChain().SupportsObjCGC()) {
2806 GCArg->render(Args, CmdArgs);
2807 } else {
2808 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002809 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00002810 << GCArg->getAsString(Args);
2811 }
2812 }
2813
John McCallb5f652e2011-06-22 00:53:57 +00002814 // Add exception args.
2815 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00002816 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00002817
2818 if (getToolChain().UseSjLjExceptions())
2819 CmdArgs.push_back("-fsjlj-exceptions");
2820
2821 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00002822 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2823 options::OPT_fno_assume_sane_operator_new))
2824 CmdArgs.push_back("-fno-assume-sane-operator-new");
2825
Daniel Dunbar34d7a992010-04-27 15:34:57 +00002826 // -fconstant-cfstrings is default, and may be subject to argument translation
2827 // on Darwin.
2828 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2829 options::OPT_fno_constant_cfstrings) ||
2830 !Args.hasFlag(options::OPT_mconstant_cfstrings,
2831 options::OPT_mno_constant_cfstrings))
2832 CmdArgs.push_back("-fno-constant-cfstrings");
2833
John Thompsoned4e2952009-11-05 20:14:16 +00002834 // -fshort-wchar default varies depending on platform; only
2835 // pass if specified.
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00002836 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2837 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00002838
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +00002839 // -fno-pascal-strings is default, only pass non-default. If the tool chain
2840 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbard4510f22009-04-07 23:51:44 +00002841 //
2842 // FIXME: This is gross; that translation should be pulled from the
2843 // tool chain.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002844 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00002845 options::OPT_fno_pascal_strings,
2846 false) ||
2847 Args.hasFlag(options::OPT_mpascal_strings,
2848 options::OPT_mno_pascal_strings,
2849 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002850 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002851
Daniel Dunbar096ed292011-10-05 21:04:55 +00002852 // Honor -fpack-struct= and -fpack-struct, if given. Note that
2853 // -fno-pack-struct doesn't apply to -fpack-struct=.
2854 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00002855 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00002856 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00002857 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00002858 } else if (Args.hasFlag(options::OPT_fpack_struct,
2859 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00002860 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00002861 }
2862
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002863 if (Args.hasArg(options::OPT_mkernel) ||
2864 Args.hasArg(options::OPT_fapple_kext)) {
2865 if (!Args.hasArg(options::OPT_fcommon))
2866 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00002867 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002868 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00002869
Daniel Dunbard18049a2009-04-07 21:16:11 +00002870 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002871 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002872 CmdArgs.push_back("-fno-common");
2873
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002874 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00002875 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00002876 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002877 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002878 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002879 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2880
Daniel Dunbar6358d682010-10-15 22:30:42 +00002881 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2882 if (!Args.hasFlag(options::OPT_ffor_scope,
2883 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002884 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00002885 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2886
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00002887 // -fcaret-diagnostics is default.
2888 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2889 options::OPT_fno_caret_diagnostics, true))
2890 CmdArgs.push_back("-fno-caret-diagnostics");
2891
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002892 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00002893 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002894 options::OPT_fno_diagnostics_fixit_info))
2895 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002896
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002897 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00002898 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002899 options::OPT_fno_diagnostics_show_option))
2900 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002901
Chris Lattnerbf6fac82010-05-04 21:55:25 +00002902 if (const Arg *A =
2903 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2904 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00002905 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00002906 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00002907
Douglas Gregor643c9222011-05-21 17:07:29 +00002908 if (const Arg *A =
2909 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2910 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00002911 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00002912 }
2913
Chandler Carruthb6766f02011-03-27 01:50:55 +00002914 if (Arg *A = Args.getLastArg(
2915 options::OPT_fdiagnostics_show_note_include_stack,
2916 options::OPT_fno_diagnostics_show_note_include_stack)) {
2917 if (A->getOption().matches(
2918 options::OPT_fdiagnostics_show_note_include_stack))
2919 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2920 else
2921 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2922 }
2923
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002924 // Color diagnostics are the default, unless the terminal doesn't support
2925 // them.
2926 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidis4f920162010-09-23 12:56:06 +00002927 options::OPT_fno_color_diagnostics,
2928 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002929 CmdArgs.push_back("-fcolor-diagnostics");
2930
Daniel Dunbardb097022009-06-08 21:13:54 +00002931 if (!Args.hasFlag(options::OPT_fshow_source_location,
2932 options::OPT_fno_show_source_location))
2933 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002934
Douglas Gregor643c9222011-05-21 17:07:29 +00002935 if (!Args.hasFlag(options::OPT_fshow_column,
2936 options::OPT_fno_show_column,
2937 true))
2938 CmdArgs.push_back("-fno-show-column");
2939
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00002940 if (!Args.hasFlag(options::OPT_fspell_checking,
2941 options::OPT_fno_spell_checking))
2942 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00002943
Daniel Dunbar473f8a62010-10-18 22:49:46 +00002944
Chad Rosierc8e56e82012-12-05 21:08:21 +00002945 // -fno-asm-blocks is default.
2946 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2947 false))
2948 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00002949
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00002950 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2951 A->render(Args, CmdArgs);
2952
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002953 // -fdollars-in-identifiers default varies depending on platform and
2954 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00002955 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002956 options::OPT_fno_dollars_in_identifiers)) {
2957 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00002958 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002959 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00002960 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002961 }
2962
Daniel Dunbaradeeb052009-05-22 19:02:20 +00002963 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
2964 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00002965 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00002966 options::OPT_fno_unit_at_a_time)) {
2967 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002968 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00002969 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00002970
Eli Friedman055c9702011-11-02 01:53:16 +00002971 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
2972 options::OPT_fno_apple_pragma_pack, false))
2973 CmdArgs.push_back("-fapple-pragma-pack");
2974
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00002975 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00002976 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002977 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00002978#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00002979 if (getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00002980 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2981 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
2982 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2983 CmdArgs.push_back("-fno-builtin-strcat");
2984 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2985 CmdArgs.push_back("-fno-builtin-strcpy");
2986 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00002987#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00002988
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00002989 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00002990 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00002991 options::OPT_traditional_cpp)) {
2992 if (isa<PreprocessJobAction>(JA))
2993 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002994 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002995 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00002996 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00002997
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002998 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00002999 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003000
3001 // Handle serialized diagnostics.
3002 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3003 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003004 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003005 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003006
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003007 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3008 CmdArgs.push_back("-fretain-comments-from-system-headers");
3009
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003010 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3011 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003012 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003013 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3014 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003015 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003016
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003017 // We translate this by hand to the -cc1 argument, since nightly test uses
3018 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003019 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003020 CmdArgs.push_back("-disable-llvm-optzns");
3021 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003022 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003023 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003024
Daniel Dunbard67a3222009-03-30 06:36:42 +00003025 if (Output.getType() == types::TY_Dependencies) {
3026 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003027 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003028 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003029 CmdArgs.push_back(Output.getFilename());
3030 } else {
3031 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003032 }
3033
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003034 for (InputInfoList::const_iterator
3035 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3036 const InputInfo &II = *it;
3037 CmdArgs.push_back("-x");
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00003038 if (Args.hasArg(options::OPT_rewrite_objc))
3039 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3040 else
3041 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbarb440f562010-08-02 02:38:21 +00003042 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003043 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003044 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003045 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003046 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003047
Chris Lattnere9d7d782009-11-03 19:50:27 +00003048 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3049
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003050 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003051
3052 // Optionally embed the -cc1 level arguments into the debug info, for build
3053 // analysis.
3054 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003055 ArgStringList OriginalArgs;
3056 for (ArgList::const_iterator it = Args.begin(),
3057 ie = Args.end(); it != ie; ++it)
3058 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003059
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003060 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003061 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003062 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003063 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003064 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003065 }
3066 CmdArgs.push_back("-dwarf-debug-flags");
3067 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3068 }
3069
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003070 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar17731772009-03-23 19:03:36 +00003071
Roman Divacky178e01602011-02-10 16:52:03 +00003072 if (Arg *A = Args.getLastArg(options::OPT_pg))
3073 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003074 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003075 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003076
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003077 // Claim some arguments which clang supports automatically.
3078
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003079 // -fpch-preprocess is used with gcc to add a special marker in the output to
3080 // include the PCH file. Clang's PTH solution is completely transparent, so we
3081 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003082 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003083
Daniel Dunbar17731772009-03-23 19:03:36 +00003084 // Claim some arguments which clang doesn't support, but we don't
3085 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003086 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3087 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003088
Rafael Espindolad95a8122011-03-01 05:25:27 +00003089 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
Rafael Espindola22f603032011-02-28 23:29:45 +00003090 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003091 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003092}
3093
Jim Grosbach576452b2012-02-10 20:37:10 +00003094void ClangAs::AddARMTargetArgs(const ArgList &Args,
3095 ArgStringList &CmdArgs) const {
3096 const Driver &D = getToolChain().getDriver();
3097 llvm::Triple Triple = getToolChain().getTriple();
3098
3099 // Set the CPU based on -march= and -mcpu=.
3100 CmdArgs.push_back("-target-cpu");
Benjamin Kramer09811c72012-06-26 22:20:06 +00003101 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
Jim Grosbach576452b2012-02-10 20:37:10 +00003102
3103 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +00003104 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +00003105 addFPUArgs(D, A, Args, CmdArgs);
Chad Rosier1f0e52e2012-04-04 20:39:32 +00003106
3107 // Honor -mfpmath=.
3108 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +00003109 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Jim Grosbach576452b2012-02-10 20:37:10 +00003110}
3111
John McCall5fb5df92012-06-20 06:18:46 +00003112/// Add options related to the Objective-C runtime/ABI.
3113///
3114/// Returns true if the runtime is non-fragile.
3115ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3116 ArgStringList &cmdArgs,
3117 RewriteKind rewriteKind) const {
3118 // Look for the controlling runtime option.
3119 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3120 options::OPT_fgnu_runtime,
3121 options::OPT_fobjc_runtime_EQ);
3122
3123 // Just forward -fobjc-runtime= to the frontend. This supercedes
3124 // options about fragility.
3125 if (runtimeArg &&
3126 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3127 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003128 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003129 if (runtime.tryParse(value)) {
3130 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3131 << value;
3132 }
3133
3134 runtimeArg->render(args, cmdArgs);
3135 return runtime;
3136 }
3137
3138 // Otherwise, we'll need the ABI "version". Version numbers are
3139 // slightly confusing for historical reasons:
3140 // 1 - Traditional "fragile" ABI
3141 // 2 - Non-fragile ABI, version 1
3142 // 3 - Non-fragile ABI, version 2
3143 unsigned objcABIVersion = 1;
3144 // If -fobjc-abi-version= is present, use that to set the version.
3145 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003146 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003147 if (value == "1")
3148 objcABIVersion = 1;
3149 else if (value == "2")
3150 objcABIVersion = 2;
3151 else if (value == "3")
3152 objcABIVersion = 3;
3153 else
3154 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3155 << value;
3156 } else {
3157 // Otherwise, determine if we are using the non-fragile ABI.
3158 bool nonFragileABIIsDefault =
3159 (rewriteKind == RK_NonFragile ||
3160 (rewriteKind == RK_None &&
3161 getToolChain().IsObjCNonFragileABIDefault()));
3162 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3163 options::OPT_fno_objc_nonfragile_abi,
3164 nonFragileABIIsDefault)) {
3165 // Determine the non-fragile ABI version to use.
3166#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3167 unsigned nonFragileABIVersion = 1;
3168#else
3169 unsigned nonFragileABIVersion = 2;
3170#endif
3171
3172 if (Arg *abiArg = args.getLastArg(
3173 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003174 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003175 if (value == "1")
3176 nonFragileABIVersion = 1;
3177 else if (value == "2")
3178 nonFragileABIVersion = 2;
3179 else
3180 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3181 << value;
3182 }
3183
3184 objcABIVersion = 1 + nonFragileABIVersion;
3185 } else {
3186 objcABIVersion = 1;
3187 }
3188 }
3189
3190 // We don't actually care about the ABI version other than whether
3191 // it's non-fragile.
3192 bool isNonFragile = objcABIVersion != 1;
3193
3194 // If we have no runtime argument, ask the toolchain for its default runtime.
3195 // However, the rewriter only really supports the Mac runtime, so assume that.
3196 ObjCRuntime runtime;
3197 if (!runtimeArg) {
3198 switch (rewriteKind) {
3199 case RK_None:
3200 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3201 break;
3202 case RK_Fragile:
3203 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3204 break;
3205 case RK_NonFragile:
3206 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3207 break;
3208 }
3209
3210 // -fnext-runtime
3211 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3212 // On Darwin, make this use the default behavior for the toolchain.
3213 if (getToolChain().getTriple().isOSDarwin()) {
3214 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3215
3216 // Otherwise, build for a generic macosx port.
3217 } else {
3218 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3219 }
3220
3221 // -fgnu-runtime
3222 } else {
3223 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00003224 // Legacy behaviour is to target the gnustep runtime if we are i
3225 // non-fragile mode or the GCC runtime in fragile mode.
3226 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00003227 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00003228 else
3229 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00003230 }
3231
3232 cmdArgs.push_back(args.MakeArgString(
3233 "-fobjc-runtime=" + runtime.getAsString()));
3234 return runtime;
3235}
3236
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003237void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003238 const InputInfo &Output,
3239 const InputInfoList &Inputs,
3240 const ArgList &Args,
3241 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003242 ArgStringList CmdArgs;
3243
3244 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3245 const InputInfo &Input = Inputs[0];
3246
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003247 // Don't warn about "clang -w -c foo.s"
3248 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003249 // and "clang -emit-llvm -c foo.s"
3250 Args.ClaimAllArgs(options::OPT_emit_llvm);
3251 // and "clang -use-gold-plugin -c foo.s"
3252 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003253
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003254 // Invoke ourselves in -cc1as mode.
3255 //
3256 // FIXME: Implement custom jobs for internal actions.
3257 CmdArgs.push_back("-cc1as");
3258
3259 // Add the "effective" target triple.
3260 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00003261 std::string TripleStr =
3262 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003263 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3264
3265 // Set the output mode, we currently only expect to be used as a real
3266 // assembler.
3267 CmdArgs.push_back("-filetype");
3268 CmdArgs.push_back("obj");
3269
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00003270 if (UseRelaxAll(C, Args))
Daniel Dunbar99ca8b72010-05-28 16:43:21 +00003271 CmdArgs.push_back("-relax-all");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003272
Jim Grosbach576452b2012-02-10 20:37:10 +00003273 // Add target specific cpu and features flags.
3274 switch(getToolChain().getTriple().getArch()) {
3275 default:
3276 break;
3277
3278 case llvm::Triple::arm:
3279 case llvm::Triple::thumb:
3280 AddARMTargetArgs(Args, CmdArgs);
3281 break;
3282 }
3283
Daniel Dunbar1d733e22011-03-17 17:37:29 +00003284 // Ignore explicit -force_cpusubtype_ALL option.
3285 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003286
Eric Christopherfc3ee562012-01-10 00:38:01 +00003287 // Determine the original source input.
3288 const Action *SourceAction = &JA;
3289 while (SourceAction->getKind() != Action::InputClass) {
3290 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3291 SourceAction = SourceAction->getInputs()[0];
3292 }
3293
3294 // Forward -g, assuming we are dealing with an actual assembly file.
3295 if (SourceAction->getType() == types::TY_Asm ||
3296 SourceAction->getType() == types::TY_PP_Asm) {
3297 Args.ClaimAllArgs(options::OPT_g_Group);
3298 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3299 if (!A->getOption().matches(options::OPT_g0))
3300 CmdArgs.push_back("-g");
3301 }
Kevin Enderby292dc082011-12-22 19:31:58 +00003302
3303 // Optionally embed the -cc1as level arguments into the debug info, for build
3304 // analysis.
3305 if (getToolChain().UseDwarfDebugFlags()) {
3306 ArgStringList OriginalArgs;
3307 for (ArgList::const_iterator it = Args.begin(),
3308 ie = Args.end(); it != ie; ++it)
3309 (*it)->render(Args, OriginalArgs);
3310
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003311 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00003312 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3313 Flags += Exec;
3314 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3315 Flags += " ";
3316 Flags += OriginalArgs[i];
3317 }
3318 CmdArgs.push_back("-dwarf-debug-flags");
3319 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3320 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003321
3322 // FIXME: Add -static support, once we have it.
3323
3324 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3325 options::OPT_Xassembler);
Daniel Dunbar252e8f92011-04-29 17:53:18 +00003326 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003327
3328 assert(Output.isFilename() && "Unexpected lipo output.");
3329 CmdArgs.push_back("-o");
3330 CmdArgs.push_back(Output.getFilename());
3331
Daniel Dunbarb440f562010-08-02 02:38:21 +00003332 assert(Input.isFilename() && "Invalid input.");
3333 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003334
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003335 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003336 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003337}
3338
Daniel Dunbara3246a02009-03-18 08:07:30 +00003339void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003340 const InputInfo &Output,
3341 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003342 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003343 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003344 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003345 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003346
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003347 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003348 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003349 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00003350 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00003351 // Don't forward any -g arguments to assembly steps.
3352 if (isa<AssembleJobAction>(JA) &&
3353 A->getOption().matches(options::OPT_g_Group))
3354 continue;
3355
Daniel Dunbar2da02722009-03-19 07:55:12 +00003356 // It is unfortunate that we have to claim here, as this means
3357 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00003358 // platforms using a generic gcc, even if we are just using gcc
3359 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00003360 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003361 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00003362 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003363 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003364
Daniel Dunbar4e295052010-01-25 22:35:08 +00003365 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003366
3367 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003368 llvm::Triple::ArchType Arch = getToolChain().getArch();
Bob Wilson6524dd32011-10-14 05:03:44 +00003369 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003370 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00003371
3372 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003373 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003374 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003375 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003376 CmdArgs.push_back("ppc64");
3377 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003378 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00003379 }
3380
Daniel Dunbar5716d872009-05-02 21:41:52 +00003381 // Try to force gcc to match the tool chain we want, if we recognize
3382 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003383 //
3384 // FIXME: The triple class should directly provide the information we want
3385 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003386 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003387 CmdArgs.push_back("-m32");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003388 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86_64)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003389 CmdArgs.push_back("-m64");
3390
Daniel Dunbarb440f562010-08-02 02:38:21 +00003391 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003392 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003393 CmdArgs.push_back(Output.getFilename());
3394 } else {
3395 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003396 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003397 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003398
Tony Linthicum76329bf2011-12-12 21:14:55 +00003399 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3400 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003401
3402 // Only pass -x if gcc will understand it; otherwise hope gcc
3403 // understands the suffix correctly. The main use case this would go
3404 // wrong in is for linker inputs if they happened to have an odd
3405 // suffix; really the only way to get this to happen is a command
3406 // like '-x foobar a.c' which will treat a.c like a linker input.
3407 //
3408 // FIXME: For the linker case specifically, can we safely convert
3409 // inputs into '-Wl,' options?
3410 for (InputInfoList::const_iterator
3411 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3412 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003413
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003414 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003415 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3416 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003417 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003418 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003419 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003420 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003421 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003422
Daniel Dunbara3246a02009-03-18 08:07:30 +00003423 if (types::canTypeBeUserSpecified(II.getType())) {
3424 CmdArgs.push_back("-x");
3425 CmdArgs.push_back(types::getTypeName(II.getType()));
3426 }
3427
Daniel Dunbarb440f562010-08-02 02:38:21 +00003428 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003429 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00003430 else {
3431 const Arg &A = II.getInputArg();
3432
3433 // Reverse translate some rewritten options.
3434 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
3435 CmdArgs.push_back("-lstdc++");
3436 continue;
3437 }
3438
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003439 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00003440 A.render(Args, CmdArgs);
3441 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003442 }
3443
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003444 const std::string customGCCName = D.getCCCGenericGCCName();
3445 const char *GCCName;
3446 if (!customGCCName.empty())
3447 GCCName = customGCCName.c_str();
3448 else if (D.CCCIsCXX) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003449 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003450 } else
3451 GCCName = "gcc";
3452
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003453 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003454 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003455 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003456}
3457
Daniel Dunbar4e295052010-01-25 22:35:08 +00003458void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
3459 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003460 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003461}
3462
Daniel Dunbar4e295052010-01-25 22:35:08 +00003463void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
3464 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003465 // The type is good enough.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003466}
3467
Daniel Dunbar4e295052010-01-25 22:35:08 +00003468void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
3469 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003470 const Driver &D = getToolChain().getDriver();
3471
Daniel Dunbar4e295052010-01-25 22:35:08 +00003472 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003473 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
3474 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00003475 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003476 else {
3477 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003478 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003479 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003480
Daniel Dunbar4e295052010-01-25 22:35:08 +00003481 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003482 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003483}
3484
Daniel Dunbar4e295052010-01-25 22:35:08 +00003485void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
3486 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003487 CmdArgs.push_back("-c");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003488}
Daniel Dunbara3246a02009-03-18 08:07:30 +00003489
Daniel Dunbar4e295052010-01-25 22:35:08 +00003490void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
3491 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003492 // The types are (hopefully) good enough.
3493}
3494
Tony Linthicum76329bf2011-12-12 21:14:55 +00003495// Hexagon tools start.
3496void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
3497 ArgStringList &CmdArgs) const {
3498
3499}
3500void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3501 const InputInfo &Output,
3502 const InputInfoList &Inputs,
3503 const ArgList &Args,
3504 const char *LinkingOutput) const {
3505
3506 const Driver &D = getToolChain().getDriver();
3507 ArgStringList CmdArgs;
3508
3509 std::string MarchString = "-march=";
3510 MarchString += getHexagonTargetCPU(Args);
3511 CmdArgs.push_back(Args.MakeArgString(MarchString));
3512
3513 RenderExtraToolArgs(JA, CmdArgs);
3514
3515 if (Output.isFilename()) {
3516 CmdArgs.push_back("-o");
3517 CmdArgs.push_back(Output.getFilename());
3518 } else {
3519 assert(Output.isNothing() && "Unexpected output");
3520 CmdArgs.push_back("-fsyntax-only");
3521 }
3522
3523
3524 // Only pass -x if gcc will understand it; otherwise hope gcc
3525 // understands the suffix correctly. The main use case this would go
3526 // wrong in is for linker inputs if they happened to have an odd
3527 // suffix; really the only way to get this to happen is a command
3528 // like '-x foobar a.c' which will treat a.c like a linker input.
3529 //
3530 // FIXME: For the linker case specifically, can we safely convert
3531 // inputs into '-Wl,' options?
3532 for (InputInfoList::const_iterator
3533 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3534 const InputInfo &II = *it;
3535
3536 // Don't try to pass LLVM or AST inputs to a generic gcc.
3537 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3538 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3539 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3540 << getToolChain().getTripleString();
3541 else if (II.getType() == types::TY_AST)
3542 D.Diag(clang::diag::err_drv_no_ast_support)
3543 << getToolChain().getTripleString();
3544
3545 if (II.isFilename())
3546 CmdArgs.push_back(II.getFilename());
3547 else
3548 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3549 II.getInputArg().render(Args, CmdArgs);
3550 }
3551
3552 const char *GCCName = "hexagon-as";
3553 const char *Exec =
3554 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3555 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3556
3557}
3558void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
3559 ArgStringList &CmdArgs) const {
3560 // The types are (hopefully) good enough.
3561}
3562
3563void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
3564 const InputInfo &Output,
3565 const InputInfoList &Inputs,
3566 const ArgList &Args,
3567 const char *LinkingOutput) const {
3568
3569 const Driver &D = getToolChain().getDriver();
3570 ArgStringList CmdArgs;
3571
3572 for (ArgList::const_iterator
3573 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
3574 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00003575 if (forwardToGCC(A->getOption())) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00003576 // Don't forward any -g arguments to assembly steps.
3577 if (isa<AssembleJobAction>(JA) &&
3578 A->getOption().matches(options::OPT_g_Group))
3579 continue;
3580
3581 // It is unfortunate that we have to claim here, as this means
3582 // we will basically never report anything interesting for
3583 // platforms using a generic gcc, even if we are just using gcc
3584 // to get to the assembler.
3585 A->claim();
3586 A->render(Args, CmdArgs);
3587 }
3588 }
3589
3590 RenderExtraToolArgs(JA, CmdArgs);
3591
3592 // Add Arch Information
3593 Arg *A;
Sebastian Pop86500282012-01-13 20:37:10 +00003594 if ((A = getLastHexagonArchArg(Args))) {
3595 if (A->getOption().matches(options::OPT_m_Joined))
3596 A->render(Args, CmdArgs);
Tony Linthicum76329bf2011-12-12 21:14:55 +00003597 else
Sebastian Pop86500282012-01-13 20:37:10 +00003598 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args)));
Tony Linthicum76329bf2011-12-12 21:14:55 +00003599 }
Sebastian Pop86500282012-01-13 20:37:10 +00003600 else {
3601 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args)));
3602 }
3603
Tony Linthicum76329bf2011-12-12 21:14:55 +00003604 CmdArgs.push_back("-mqdsp6-compat");
3605
3606 const char *GCCName;
3607 if (C.getDriver().CCCIsCXX)
3608 GCCName = "hexagon-g++";
3609 else
3610 GCCName = "hexagon-gcc";
3611 const char *Exec =
3612 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3613
3614 if (Output.isFilename()) {
3615 CmdArgs.push_back("-o");
3616 CmdArgs.push_back(Output.getFilename());
3617 }
3618
3619 for (InputInfoList::const_iterator
3620 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3621 const InputInfo &II = *it;
3622
3623 // Don't try to pass LLVM or AST inputs to a generic gcc.
3624 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3625 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3626 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3627 << getToolChain().getTripleString();
3628 else if (II.getType() == types::TY_AST)
3629 D.Diag(clang::diag::err_drv_no_ast_support)
3630 << getToolChain().getTripleString();
3631
3632 if (II.isFilename())
3633 CmdArgs.push_back(II.getFilename());
3634 else
3635 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3636 II.getInputArg().render(Args, CmdArgs);
3637 }
3638 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3639
3640}
3641// Hexagon tools end.
3642
Rafael Espindoladcbf6982012-10-31 18:51:07 +00003643llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
3644 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
3645 // archs which Darwin doesn't use.
3646
3647 // The matching this routine does is fairly pointless, since it is neither the
3648 // complete architecture list, nor a reasonable subset. The problem is that
3649 // historically the driver driver accepts this and also ties its -march=
3650 // handling to the architecture name, so we need to be careful before removing
3651 // support for it.
3652
3653 // This code must be kept in sync with Clang's Darwin specific argument
3654 // translation.
3655
3656 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
3657 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
3658 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
3659 .Case("ppc64", llvm::Triple::ppc64)
3660 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
3661 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
3662 llvm::Triple::x86)
3663 .Case("x86_64", llvm::Triple::x86_64)
3664 // This is derived from the driver driver.
3665 .Cases("arm", "armv4t", "armv5", "armv6", llvm::Triple::arm)
3666 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", llvm::Triple::arm)
3667 .Case("r600", llvm::Triple::r600)
3668 .Case("nvptx", llvm::Triple::nvptx)
3669 .Case("nvptx64", llvm::Triple::nvptx64)
3670 .Case("amdil", llvm::Triple::amdil)
3671 .Case("spir", llvm::Triple::spir)
3672 .Default(llvm::Triple::UnknownArch);
3673}
Tony Linthicum76329bf2011-12-12 21:14:55 +00003674
Bob Wilsondecc03e2012-11-23 06:14:39 +00003675const char *Clang::getBaseInputName(const ArgList &Args,
3676 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00003677 return Args.MakeArgString(
3678 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003679}
3680
Bob Wilsondecc03e2012-11-23 06:14:39 +00003681const char *Clang::getBaseInputStem(const ArgList &Args,
3682 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003683 const char *Str = getBaseInputName(Args, Inputs);
3684
Chris Lattner906bb902011-01-16 08:14:11 +00003685 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003686 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003687
3688 return Str;
3689}
3690
Bob Wilsondecc03e2012-11-23 06:14:39 +00003691const char *Clang::getDependencyFileName(const ArgList &Args,
3692 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003693 // FIXME: Think about this more.
3694 std::string Res;
3695
3696 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003697 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003698 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003699 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00003700 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003701 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003702 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003703}
3704
Daniel Dunbarbe220842009-03-20 16:06:39 +00003705void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003706 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003707 const InputInfoList &Inputs,
3708 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00003709 const char *LinkingOutput) const {
3710 ArgStringList CmdArgs;
3711
3712 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3713 const InputInfo &Input = Inputs[0];
3714
Daniel Dunbardc8355e2011-04-12 23:59:20 +00003715 // Determine the original source input.
3716 const Action *SourceAction = &JA;
3717 while (SourceAction->getKind() != Action::InputClass) {
3718 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3719 SourceAction = SourceAction->getInputs()[0];
3720 }
3721
3722 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00003723 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00003724 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00003725 if (Args.hasArg(options::OPT_gstabs))
3726 CmdArgs.push_back("--gstabs");
3727 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00003728 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00003729 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003730
Daniel Dunbarbe220842009-03-20 16:06:39 +00003731 // Derived from asm spec.
Daniel Dunbar3571dd92009-09-09 18:36:27 +00003732 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00003733
Daniel Dunbar6d484762010-07-22 01:47:22 +00003734 // Use -force_cpusubtype_ALL on x86 by default.
3735 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
3736 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00003737 Args.hasArg(options::OPT_force__cpusubtype__ALL))
3738 CmdArgs.push_back("-force_cpusubtype_ALL");
3739
Daniel Dunbara6b4a3d2009-08-24 22:26:16 +00003740 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00003741 (((Args.hasArg(options::OPT_mkernel) ||
3742 Args.hasArg(options::OPT_fapple_kext)) &&
3743 (!getDarwinToolChain().isTargetIPhoneOS() ||
3744 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
3745 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003746 CmdArgs.push_back("-static");
3747
Daniel Dunbarbe220842009-03-20 16:06:39 +00003748 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3749 options::OPT_Xassembler);
3750
3751 assert(Output.isFilename() && "Unexpected lipo output.");
3752 CmdArgs.push_back("-o");
3753 CmdArgs.push_back(Output.getFilename());
3754
Daniel Dunbarb440f562010-08-02 02:38:21 +00003755 assert(Input.isFilename() && "Invalid input.");
3756 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00003757
3758 // asm_final spec is empty.
3759
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003760 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003761 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003762 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00003763}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00003764
David Blaikie68e081d2011-12-20 02:48:34 +00003765void darwin::DarwinTool::anchor() {}
3766
Daniel Dunbare9ded432009-09-09 18:36:20 +00003767void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
3768 ArgStringList &CmdArgs) const {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003769 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00003770
Daniel Dunbarc1964212009-03-26 16:23:12 +00003771 // Derived from darwin_arch spec.
3772 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00003773 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00003774
Daniel Dunbardcc3b652010-01-22 02:04:58 +00003775 // FIXME: Is this needed anymore?
3776 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00003777 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00003778}
3779
Bill Wendling3b2000f2012-10-02 18:02:50 +00003780bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
3781 // We only need to generate a temp path for LTO if we aren't compiling object
3782 // files. When compiling source files, we run 'dsymutil' after linking. We
3783 // don't run 'dsymutil' when compiling object files.
3784 for (InputInfoList::const_iterator
3785 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
3786 if (it->getType() != types::TY_Object)
3787 return true;
3788
3789 return false;
3790}
3791
Daniel Dunbarccbc4522010-09-09 21:51:05 +00003792void darwin::Link::AddLinkArgs(Compilation &C,
3793 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00003794 ArgStringList &CmdArgs,
3795 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003796 const Driver &D = getToolChain().getDriver();
Daniel Dunbarc44d3132011-04-28 21:23:41 +00003797 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00003798
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003799 unsigned Version[3] = { 0, 0, 0 };
3800 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3801 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00003802 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003803 Version[1], Version[2], HadExtra) ||
3804 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003805 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003806 << A->getAsString(Args);
3807 }
3808
3809 // Newer linkers support -demangle, pass it if supported and not disabled by
3810 // the user.
Daniel Dunbarecb41cb2012-01-04 21:45:27 +00003811 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00003812 // Don't pass -demangle to ld_classic.
3813 //
3814 // FIXME: This is a temporary workaround, ld should be handling this.
3815 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
3816 Args.hasArg(options::OPT_static));
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00003817 if (getToolChain().getArch() == llvm::Triple::x86) {
3818 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
3819 options::OPT_Wl_COMMA),
3820 ie = Args.filtered_end(); it != ie; ++it) {
3821 const Arg *A = *it;
3822 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Richard Smithbd55daf2012-11-01 04:30:05 +00003823 if (StringRef(A->getValue(i)) == "-kext")
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00003824 UsesLdClassic = true;
3825 }
3826 }
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00003827 if (!UsesLdClassic)
3828 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003829 }
3830
Bill Wendling313b6bf2012-11-16 23:03:00 +00003831 // If we are using LTO, then automatically create a temporary file path for
3832 // the linker to use, so that it's lifetime will extend past a possible
3833 // dsymutil step.
3834 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
3835 const char *TmpPath = C.getArgs().MakeArgString(
3836 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
3837 C.addTempFile(TmpPath);
3838 CmdArgs.push_back("-object_path_lto");
3839 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00003840 }
3841
Daniel Dunbarc1964212009-03-26 16:23:12 +00003842 // Derived from the "link" spec.
3843 Args.AddAllArgs(CmdArgs, options::OPT_static);
3844 if (!Args.hasArg(options::OPT_static))
3845 CmdArgs.push_back("-dynamic");
3846 if (Args.hasArg(options::OPT_fgnu_runtime)) {
3847 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
3848 // here. How do we wish to handle such things?
3849 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003850
Daniel Dunbarc1964212009-03-26 16:23:12 +00003851 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara48823f2010-01-22 02:04:52 +00003852 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00003853 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00003854 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00003855
3856 Args.AddLastArg(CmdArgs, options::OPT_bundle);
3857 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
3858 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
3859
3860 Arg *A;
3861 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
3862 (A = Args.getLastArg(options::OPT_current__version)) ||
3863 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003864 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00003865 << A->getAsString(Args) << "-dynamiclib";
3866
3867 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
3868 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
3869 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
3870 } else {
3871 CmdArgs.push_back("-dylib");
3872
3873 Arg *A;
3874 if ((A = Args.getLastArg(options::OPT_bundle)) ||
3875 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
3876 (A = Args.getLastArg(options::OPT_client__name)) ||
3877 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
3878 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
3879 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003880 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00003881 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003882
Daniel Dunbarc1964212009-03-26 16:23:12 +00003883 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
3884 "-dylib_compatibility_version");
3885 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
3886 "-dylib_current_version");
3887
Daniel Dunbara48823f2010-01-22 02:04:52 +00003888 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00003889
3890 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
3891 "-dylib_install_name");
3892 }
3893
3894 Args.AddLastArg(CmdArgs, options::OPT_all__load);
3895 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
3896 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00003897 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00003898 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00003899 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
3900 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
3901 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
3902 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
3903 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
3904 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00003905 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00003906 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
3907 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
3908 Args.AddAllArgs(CmdArgs, options::OPT_init);
3909
Daniel Dunbarc44d3132011-04-28 21:23:41 +00003910 // Add the deployment target.
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00003911 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
Daniel Dunbar72ceb922011-04-30 04:22:58 +00003912
3913 // If we had an explicit -mios-simulator-version-min argument, honor that,
3914 // otherwise use the traditional deployment targets. We can't just check the
3915 // is-sim attribute because existing code follows this path, and the linker
3916 // may not handle the argument.
3917 //
3918 // FIXME: We may be able to remove this, once we can verify no one depends on
3919 // it.
3920 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
3921 CmdArgs.push_back("-ios_simulator_version_min");
3922 else if (DarwinTC.isTargetIPhoneOS())
3923 CmdArgs.push_back("-iphoneos_version_min");
3924 else
3925 CmdArgs.push_back("-macosx_version_min");
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00003926 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
Daniel Dunbarc44d3132011-04-28 21:23:41 +00003927
Daniel Dunbarc1964212009-03-26 16:23:12 +00003928 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
3929 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
3930 Args.AddLastArg(CmdArgs, options::OPT_single__module);
3931 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
3932 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003933
Daniel Dunbaraf68a882010-07-13 23:31:40 +00003934 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
3935 options::OPT_fno_pie,
3936 options::OPT_fno_PIE)) {
3937 if (A->getOption().matches(options::OPT_fpie) ||
3938 A->getOption().matches(options::OPT_fPIE))
3939 CmdArgs.push_back("-pie");
3940 else
3941 CmdArgs.push_back("-no_pie");
3942 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00003943
3944 Args.AddLastArg(CmdArgs, options::OPT_prebind);
3945 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
3946 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
3947 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
3948 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
3949 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
3950 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
3951 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
3952 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
3953 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
3954 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
3955 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
3956 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
3957 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
3958 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
3959 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00003960
Daniel Dunbar84384642011-05-02 21:03:47 +00003961 // Give --sysroot= preference, over the Apple specific behavior to also use
3962 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00003963 StringRef sysroot = C.getSysRoot();
3964 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00003965 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00003966 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00003967 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
3968 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00003969 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00003970 }
3971
Daniel Dunbarc1964212009-03-26 16:23:12 +00003972 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
3973 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
3974 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
3975 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
3976 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00003977 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00003978 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
3979 Args.AddAllArgs(CmdArgs, options::OPT_y);
3980 Args.AddLastArg(CmdArgs, options::OPT_w);
3981 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
3982 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
3983 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
3984 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
3985 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
3986 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
3987 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
3988 Args.AddLastArg(CmdArgs, options::OPT_whyload);
3989 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
3990 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
3991 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
3992 Args.AddLastArg(CmdArgs, options::OPT_Mach);
3993}
3994
3995void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003996 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003997 const InputInfoList &Inputs,
3998 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00003999 const char *LinkingOutput) const {
4000 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00004001
Daniel Dunbarc1964212009-03-26 16:23:12 +00004002 // The logic here is derived from gcc's behavior; most of which
4003 // comes from specs (starting with link_command). Consult gcc for
4004 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00004005 ArgStringList CmdArgs;
4006
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00004007 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4008 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4009 options::OPT_ccc_arcmt_migrate)) {
4010 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4011 (*I)->claim();
4012 const char *Exec =
4013 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4014 CmdArgs.push_back(Output.getFilename());
4015 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4016 return;
4017 }
4018
Daniel Dunbarc1964212009-03-26 16:23:12 +00004019 // I'm not sure why this particular decomposition exists in gcc, but
4020 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00004021 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004022
Daniel Dunbarc1964212009-03-26 16:23:12 +00004023 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4024 Args.AddAllArgs(CmdArgs, options::OPT_s);
4025 Args.AddAllArgs(CmdArgs, options::OPT_t);
4026 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4027 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004028 Args.AddLastArg(CmdArgs, options::OPT_e);
4029 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4030 Args.AddAllArgs(CmdArgs, options::OPT_r);
4031
Daniel Dunbar767bbab2010-10-18 22:08:36 +00004032 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4033 // members of static archive libraries which implement Objective-C classes or
4034 // categories.
4035 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4036 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004037
Daniel Dunbarc1964212009-03-26 16:23:12 +00004038 CmdArgs.push_back("-o");
4039 CmdArgs.push_back(Output.getFilename());
4040
Chad Rosier06fd3c62012-05-16 23:45:12 +00004041 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004042 !Args.hasArg(options::OPT_nostartfiles)) {
4043 // Derived from startfile spec.
4044 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004045 // Derived from darwin_dylib1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004046 if (getDarwinToolChain().isTargetIOSSimulator()) {
4047 // The simulator doesn't have a versioned crt1 file.
4048 CmdArgs.push_back("-ldylib1.o");
4049 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004050 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4051 CmdArgs.push_back("-ldylib1.o");
4052 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004053 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbar83608032010-01-27 00:56:56 +00004054 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004055 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004056 CmdArgs.push_back("-ldylib1.10.5.o");
4057 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004058 } else {
4059 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004060 if (!Args.hasArg(options::OPT_static)) {
4061 // Derived from darwin_bundle1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004062 if (getDarwinToolChain().isTargetIOSSimulator()) {
4063 // The simulator doesn't have a versioned crt1 file.
4064 CmdArgs.push_back("-lbundle1.o");
4065 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004066 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4067 CmdArgs.push_back("-lbundle1.o");
4068 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004069 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004070 CmdArgs.push_back("-lbundle1.o");
4071 }
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004072 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004073 } else {
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004074 if (Args.hasArg(options::OPT_pg) &&
4075 getToolChain().SupportsProfiling()) {
Daniel Dunbarc1964212009-03-26 16:23:12 +00004076 if (Args.hasArg(options::OPT_static) ||
4077 Args.hasArg(options::OPT_object) ||
4078 Args.hasArg(options::OPT_preload)) {
4079 CmdArgs.push_back("-lgcrt0.o");
4080 } else {
4081 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004082
Daniel Dunbarc1964212009-03-26 16:23:12 +00004083 // darwin_crt2 spec is empty.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004084 }
Bob Wilsonef285b42012-07-04 00:18:41 +00004085 // By default on OS X 10.8 and later, we don't link with a crt1.o
4086 // file and the linker knows to use _main as the entry point. But,
4087 // when compiling with -pg, we need to link with the gcrt1.o file,
4088 // so pass the -no_new_main option to tell the linker to use the
4089 // "start" symbol as the entry point.
Bob Wilson1e148fe2012-07-03 20:42:10 +00004090 if (getDarwinToolChain().isTargetMacOS() &&
4091 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4092 CmdArgs.push_back("-no_new_main");
Daniel Dunbarc1964212009-03-26 16:23:12 +00004093 } else {
4094 if (Args.hasArg(options::OPT_static) ||
4095 Args.hasArg(options::OPT_object) ||
4096 Args.hasArg(options::OPT_preload)) {
4097 CmdArgs.push_back("-lcrt0.o");
4098 } else {
4099 // Derived from darwin_crt1 spec.
Daniel Dunbarebc34df2011-03-31 17:12:33 +00004100 if (getDarwinToolChain().isTargetIOSSimulator()) {
4101 // The simulator doesn't have a versioned crt1 file.
4102 CmdArgs.push_back("-lcrt1.o");
4103 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004104 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4105 CmdArgs.push_back("-lcrt1.o");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004106 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
Daniel Dunbar83608032010-01-27 00:56:56 +00004107 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004108 } else {
4109 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4110 CmdArgs.push_back("-lcrt1.o");
4111 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4112 CmdArgs.push_back("-lcrt1.10.5.o");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004113 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004114 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004115
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004116 // darwin_crt2 spec is empty.
4117 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004118 }
4119 }
4120 }
4121 }
4122
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004123 if (!getDarwinToolChain().isTargetIPhoneOS() &&
4124 Args.hasArg(options::OPT_shared_libgcc) &&
4125 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004126 const char *Str =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004127 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004128 CmdArgs.push_back(Str);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004129 }
4130 }
4131
4132 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004133
Alexey Samsonov627b10f2012-11-06 15:09:03 +00004134 SanitizerArgs Sanitize(getToolChain().getDriver(), Args);
Alexey Samsonovcc429802012-11-16 12:53:14 +00004135 // If we're building a dynamic lib with -fsanitize=address, or
4136 // -fsanitize=undefined, unresolved symbols may appear. Mark all
4137 // of them as dynamic_lookup. Linking executables is handled in
4138 // lib/Driver/ToolChains.cpp.
4139 if (Sanitize.needsAsanRt() || Sanitize.needsUbsanRt()) {
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00004140 if (Args.hasArg(options::OPT_dynamiclib) ||
4141 Args.hasArg(options::OPT_bundle)) {
4142 CmdArgs.push_back("-undefined");
4143 CmdArgs.push_back("dynamic_lookup");
4144 }
4145 }
4146
Daniel Dunbarc1964212009-03-26 16:23:12 +00004147 if (Args.hasArg(options::OPT_fopenmp))
4148 // This is more complicated in gcc...
4149 CmdArgs.push_back("-lgomp");
4150
Douglas Gregor9295df02012-05-15 21:00:27 +00004151 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4152
Bob Wilson16d93952012-05-15 18:57:39 +00004153 if (isObjCRuntimeLinked(Args) &&
4154 !Args.hasArg(options::OPT_nostdlib) &&
4155 !Args.hasArg(options::OPT_nodefaultlibs)) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004156 // Avoid linking compatibility stubs on i386 mac.
4157 if (!getDarwinToolChain().isTargetMacOS() ||
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004158 getDarwinToolChain().getArch() != llvm::Triple::x86) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004159 // If we don't have ARC or subscripting runtime support, link in the
4160 // runtime stubs. We have to do this *before* adding any of the normal
4161 // linker inputs so that its initializer gets run first.
John McCall5fb5df92012-06-20 06:18:46 +00004162 ObjCRuntime runtime =
4163 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004164 // We use arclite library for both ARC and subscripting support.
John McCall3deb1ad2012-08-21 02:47:43 +00004165 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
John McCall5fb5df92012-06-20 06:18:46 +00004166 !runtime.hasSubscripting())
Ted Kremeneke65b0862012-03-06 20:05:56 +00004167 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004168 }
Bob Wilson7dda0cd2012-04-21 00:21:42 +00004169 CmdArgs.push_back("-framework");
4170 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004171 // Link libobj.
4172 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00004173 }
John McCall31168b02011-06-15 23:02:42 +00004174
Daniel Dunbarc1964212009-03-26 16:23:12 +00004175 if (LinkingOutput) {
4176 CmdArgs.push_back("-arch_multiple");
4177 CmdArgs.push_back("-final_output");
4178 CmdArgs.push_back(LinkingOutput);
4179 }
4180
Daniel Dunbarc1964212009-03-26 16:23:12 +00004181 if (Args.hasArg(options::OPT_fnested_functions))
4182 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004183
Daniel Dunbarc1964212009-03-26 16:23:12 +00004184 if (!Args.hasArg(options::OPT_nostdlib) &&
4185 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004186 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004187 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00004188
Daniel Dunbarc1964212009-03-26 16:23:12 +00004189 // link_ssp spec is empty.
4190
Daniel Dunbar26d482a2009-09-18 08:15:03 +00004191 // Let the tool chain choose which runtime library to link.
4192 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004193 }
4194
Chad Rosier06fd3c62012-05-16 23:45:12 +00004195 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004196 !Args.hasArg(options::OPT_nostartfiles)) {
4197 // endfile_spec is empty.
4198 }
4199
4200 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4201 Args.AddAllArgs(CmdArgs, options::OPT_F);
4202
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004203 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004204 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004205 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00004206}
4207
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004208void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004209 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004210 const InputInfoList &Inputs,
4211 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004212 const char *LinkingOutput) const {
4213 ArgStringList CmdArgs;
4214
4215 CmdArgs.push_back("-create");
4216 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004217
4218 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004219 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004220
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004221 for (InputInfoList::const_iterator
4222 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4223 const InputInfo &II = *it;
4224 assert(II.isFilename() && "Unexpected lipo input.");
4225 CmdArgs.push_back(II.getFilename());
4226 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004227 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004228 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004229 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004230}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004231
Daniel Dunbar88299622010-06-04 18:28:36 +00004232void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004233 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00004234 const InputInfoList &Inputs,
4235 const ArgList &Args,
4236 const char *LinkingOutput) const {
4237 ArgStringList CmdArgs;
4238
Daniel Dunbareb86b042011-05-09 17:23:16 +00004239 CmdArgs.push_back("-o");
4240 CmdArgs.push_back(Output.getFilename());
4241
Daniel Dunbar88299622010-06-04 18:28:36 +00004242 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4243 const InputInfo &Input = Inputs[0];
4244 assert(Input.isFilename() && "Unexpected dsymutil input.");
4245 CmdArgs.push_back(Input.getFilename());
4246
Daniel Dunbar88299622010-06-04 18:28:36 +00004247 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004248 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004249 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00004250}
4251
Eric Christopher551ef452011-08-23 17:56:55 +00004252void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
4253 const InputInfo &Output,
4254 const InputInfoList &Inputs,
4255 const ArgList &Args,
4256 const char *LinkingOutput) const {
4257 ArgStringList CmdArgs;
4258 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00004259 CmdArgs.push_back("--debug-info");
4260 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00004261 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00004262
4263 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4264 const InputInfo &Input = Inputs[0];
4265 assert(Input.isFilename() && "Unexpected verify input");
4266
4267 // Grabbing the output of the earlier dsymutil run.
4268 CmdArgs.push_back(Input.getFilename());
4269
4270 const char *Exec =
4271 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4272 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4273}
4274
David Chisnallf571cde2012-02-15 13:39:01 +00004275void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4276 const InputInfo &Output,
4277 const InputInfoList &Inputs,
4278 const ArgList &Args,
4279 const char *LinkingOutput) const {
4280 ArgStringList CmdArgs;
4281
4282 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4283 options::OPT_Xassembler);
4284
4285 CmdArgs.push_back("-o");
4286 CmdArgs.push_back(Output.getFilename());
4287
4288 for (InputInfoList::const_iterator
4289 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4290 const InputInfo &II = *it;
4291 CmdArgs.push_back(II.getFilename());
4292 }
4293
4294 const char *Exec =
4295 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4296 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4297}
4298
4299
4300void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4301 const InputInfo &Output,
4302 const InputInfoList &Inputs,
4303 const ArgList &Args,
4304 const char *LinkingOutput) const {
4305 // FIXME: Find a real GCC, don't hard-code versions here
4306 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4307 const llvm::Triple &T = getToolChain().getTriple();
4308 std::string LibPath = "/usr/lib/";
4309 llvm::Triple::ArchType Arch = T.getArch();
4310 switch (Arch) {
4311 case llvm::Triple::x86:
4312 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4313 T.getOSName()).str() + "/4.5.2/";
4314 break;
4315 case llvm::Triple::x86_64:
4316 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4317 T.getOSName()).str();
4318 GCCLibPath += "/4.5.2/amd64/";
4319 LibPath += "amd64/";
4320 break;
4321 default:
4322 assert(0 && "Unsupported architecture");
4323 }
4324
4325 ArgStringList CmdArgs;
4326
David Chisnall272a0712012-02-29 15:06:12 +00004327 // Demangle C++ names in errors
4328 CmdArgs.push_back("-C");
4329
David Chisnallf571cde2012-02-15 13:39:01 +00004330 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4331 (!Args.hasArg(options::OPT_shared))) {
4332 CmdArgs.push_back("-e");
4333 CmdArgs.push_back("_start");
4334 }
4335
4336 if (Args.hasArg(options::OPT_static)) {
4337 CmdArgs.push_back("-Bstatic");
4338 CmdArgs.push_back("-dn");
4339 } else {
4340 CmdArgs.push_back("-Bdynamic");
4341 if (Args.hasArg(options::OPT_shared)) {
4342 CmdArgs.push_back("-shared");
4343 } else {
4344 CmdArgs.push_back("--dynamic-linker");
4345 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
4346 }
4347 }
4348
4349 if (Output.isFilename()) {
4350 CmdArgs.push_back("-o");
4351 CmdArgs.push_back(Output.getFilename());
4352 } else {
4353 assert(Output.isNothing() && "Invalid output.");
4354 }
4355
4356 if (!Args.hasArg(options::OPT_nostdlib) &&
4357 !Args.hasArg(options::OPT_nostartfiles)) {
4358 if (!Args.hasArg(options::OPT_shared)) {
4359 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
4360 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004361 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004362 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4363 } else {
4364 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004365 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4366 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004367 }
David Chisnallddc4c9d2012-03-13 14:14:54 +00004368 if (getToolChain().getDriver().CCCIsCXX)
4369 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004370 }
4371
4372 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
4373
4374 Args.AddAllArgs(CmdArgs, options::OPT_L);
4375 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4376 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00004377 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00004378
4379 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4380
4381 if (!Args.hasArg(options::OPT_nostdlib) &&
4382 !Args.hasArg(options::OPT_nodefaultlibs)) {
David Chisnall3d127c72012-04-10 11:49:50 +00004383 if (getToolChain().getDriver().CCCIsCXX)
4384 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00004385 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004386 if (!Args.hasArg(options::OPT_shared)) {
4387 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00004388 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00004389 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004390 }
David Chisnallf571cde2012-02-15 13:39:01 +00004391 }
4392
4393 if (!Args.hasArg(options::OPT_nostdlib) &&
4394 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00004395 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004396 }
David Chisnall96de9932012-02-16 16:00:47 +00004397 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004398
4399 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4400
4401 const char *Exec =
4402 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4403 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4404}
4405
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004406void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004407 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004408 const InputInfoList &Inputs,
4409 const ArgList &Args,
4410 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004411 ArgStringList CmdArgs;
4412
4413 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4414 options::OPT_Xassembler);
4415
4416 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004417 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004418
4419 for (InputInfoList::const_iterator
4420 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4421 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004422 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004423 }
4424
4425 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004426 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004427 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004428}
4429
4430void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004431 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004432 const InputInfoList &Inputs,
4433 const ArgList &Args,
4434 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004435 ArgStringList CmdArgs;
4436
4437 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004438 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004439 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004440 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004441 }
4442
4443 if (Args.hasArg(options::OPT_static)) {
4444 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004445 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004446 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004447// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004448 CmdArgs.push_back("-Bdynamic");
4449 if (Args.hasArg(options::OPT_shared)) {
4450 CmdArgs.push_back("-shared");
4451 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00004452 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004453 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
4454 }
4455 }
4456
Daniel Dunbarb440f562010-08-02 02:38:21 +00004457 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004458 CmdArgs.push_back("-o");
4459 CmdArgs.push_back(Output.getFilename());
4460 } else {
4461 assert(Output.isNothing() && "Invalid output.");
4462 }
4463
4464 if (!Args.hasArg(options::OPT_nostdlib) &&
4465 !Args.hasArg(options::OPT_nostartfiles)) {
4466 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004467 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004468 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004469 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004470 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004471 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004472 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004473 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004474 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004475 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004476 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00004477 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004478 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004479 }
4480
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004481 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
4482 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00004483 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004484
4485 Args.AddAllArgs(CmdArgs, options::OPT_L);
4486 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4487 Args.AddAllArgs(CmdArgs, options::OPT_e);
4488
Daniel Dunbar54423b22010-09-17 00:24:54 +00004489 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004490
4491 if (!Args.hasArg(options::OPT_nostdlib) &&
4492 !Args.hasArg(options::OPT_nodefaultlibs)) {
4493 // FIXME: For some reason GCC passes -lgcc before adding
4494 // the default system libraries. Just mimic this for now.
4495 CmdArgs.push_back("-lgcc");
4496
4497 if (Args.hasArg(options::OPT_pthread))
4498 CmdArgs.push_back("-pthread");
4499 if (!Args.hasArg(options::OPT_shared))
4500 CmdArgs.push_back("-lc");
4501 CmdArgs.push_back("-lgcc");
4502 }
4503
4504 if (!Args.hasArg(options::OPT_nostdlib) &&
4505 !Args.hasArg(options::OPT_nostartfiles)) {
4506 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00004507 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004508 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004509 }
4510
Bill Wendling08760582011-06-27 19:15:03 +00004511 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00004512
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004513 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004514 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004515 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004516}
4517
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004518void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004519 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004520 const InputInfoList &Inputs,
4521 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00004522 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004523 ArgStringList CmdArgs;
4524
4525 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4526 options::OPT_Xassembler);
4527
4528 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004529 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004530
4531 for (InputInfoList::const_iterator
4532 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4533 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004534 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004535 }
4536
4537 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004538 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004539 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004540}
4541
4542void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004543 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004544 const InputInfoList &Inputs,
4545 const ArgList &Args,
4546 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004547 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004548 ArgStringList CmdArgs;
4549
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004550 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004551 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004552 CmdArgs.push_back("-e");
4553 CmdArgs.push_back("__start");
4554 }
4555
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004556 if (Args.hasArg(options::OPT_static)) {
4557 CmdArgs.push_back("-Bstatic");
4558 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00004559 if (Args.hasArg(options::OPT_rdynamic))
4560 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004561 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004562 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004563 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004564 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004565 } else {
4566 CmdArgs.push_back("-dynamic-linker");
4567 CmdArgs.push_back("/usr/libexec/ld.so");
4568 }
4569 }
4570
Daniel Dunbarb440f562010-08-02 02:38:21 +00004571 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004572 CmdArgs.push_back("-o");
4573 CmdArgs.push_back(Output.getFilename());
4574 } else {
4575 assert(Output.isNothing() && "Invalid output.");
4576 }
4577
4578 if (!Args.hasArg(options::OPT_nostdlib) &&
4579 !Args.hasArg(options::OPT_nostartfiles)) {
4580 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00004581 if (Args.hasArg(options::OPT_pg))
4582 CmdArgs.push_back(Args.MakeArgString(
4583 getToolChain().GetFilePath("gcrt0.o")));
4584 else
4585 CmdArgs.push_back(Args.MakeArgString(
4586 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004587 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004588 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004589 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004590 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004591 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004592 }
4593 }
4594
Edward O'Callaghan5c521462009-10-28 15:13:08 +00004595 std::string Triple = getToolChain().getTripleString();
4596 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004597 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00004598 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004599 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004600
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004601 Args.AddAllArgs(CmdArgs, options::OPT_L);
4602 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4603 Args.AddAllArgs(CmdArgs, options::OPT_e);
4604
Daniel Dunbar54423b22010-09-17 00:24:54 +00004605 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004606
4607 if (!Args.hasArg(options::OPT_nostdlib) &&
4608 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004609 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004610 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00004611 if (Args.hasArg(options::OPT_pg))
4612 CmdArgs.push_back("-lm_p");
4613 else
4614 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004615 }
4616
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004617 // FIXME: For some reason GCC passes -lgcc before adding
4618 // the default system libraries. Just mimic this for now.
4619 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004620
Eric Christopher17674ec2012-09-13 06:32:34 +00004621 if (Args.hasArg(options::OPT_pthread)) {
4622 if (!Args.hasArg(options::OPT_shared) &&
4623 Args.hasArg(options::OPT_pg))
4624 CmdArgs.push_back("-lpthread_p");
4625 else
4626 CmdArgs.push_back("-lpthread");
4627 }
4628
Chandler Carruth45661652011-12-17 22:32:42 +00004629 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00004630 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00004631 CmdArgs.push_back("-lc_p");
4632 else
4633 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00004634 }
Eric Christopher17674ec2012-09-13 06:32:34 +00004635
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004636 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004637 }
4638
4639 if (!Args.hasArg(options::OPT_nostdlib) &&
4640 !Args.hasArg(options::OPT_nostartfiles)) {
4641 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00004642 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004643 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004644 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00004645 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004646 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004647 }
4648
4649 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004650 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004651 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004652}
Ed Schoutene33194b2009-04-02 19:13:12 +00004653
Eli Friedman9fa28852012-08-08 23:57:20 +00004654void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4655 const InputInfo &Output,
4656 const InputInfoList &Inputs,
4657 const ArgList &Args,
4658 const char *LinkingOutput) const {
4659 ArgStringList CmdArgs;
4660
4661 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4662 options::OPT_Xassembler);
4663
4664 CmdArgs.push_back("-o");
4665 CmdArgs.push_back(Output.getFilename());
4666
4667 for (InputInfoList::const_iterator
4668 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4669 const InputInfo &II = *it;
4670 CmdArgs.push_back(II.getFilename());
4671 }
4672
4673 const char *Exec =
4674 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4675 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4676}
4677
4678void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
4679 const InputInfo &Output,
4680 const InputInfoList &Inputs,
4681 const ArgList &Args,
4682 const char *LinkingOutput) const {
4683 const Driver &D = getToolChain().getDriver();
4684 ArgStringList CmdArgs;
4685
4686 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4687 (!Args.hasArg(options::OPT_shared))) {
4688 CmdArgs.push_back("-e");
4689 CmdArgs.push_back("__start");
4690 }
4691
4692 if (Args.hasArg(options::OPT_static)) {
4693 CmdArgs.push_back("-Bstatic");
4694 } else {
4695 if (Args.hasArg(options::OPT_rdynamic))
4696 CmdArgs.push_back("-export-dynamic");
4697 CmdArgs.push_back("--eh-frame-hdr");
4698 CmdArgs.push_back("-Bdynamic");
4699 if (Args.hasArg(options::OPT_shared)) {
4700 CmdArgs.push_back("-shared");
4701 } else {
4702 CmdArgs.push_back("-dynamic-linker");
4703 CmdArgs.push_back("/usr/libexec/ld.so");
4704 }
4705 }
4706
4707 if (Output.isFilename()) {
4708 CmdArgs.push_back("-o");
4709 CmdArgs.push_back(Output.getFilename());
4710 } else {
4711 assert(Output.isNothing() && "Invalid output.");
4712 }
4713
4714 if (!Args.hasArg(options::OPT_nostdlib) &&
4715 !Args.hasArg(options::OPT_nostartfiles)) {
4716 if (!Args.hasArg(options::OPT_shared)) {
4717 if (Args.hasArg(options::OPT_pg))
4718 CmdArgs.push_back(Args.MakeArgString(
4719 getToolChain().GetFilePath("gcrt0.o")));
4720 else
4721 CmdArgs.push_back(Args.MakeArgString(
4722 getToolChain().GetFilePath("crt0.o")));
4723 CmdArgs.push_back(Args.MakeArgString(
4724 getToolChain().GetFilePath("crtbegin.o")));
4725 } else {
4726 CmdArgs.push_back(Args.MakeArgString(
4727 getToolChain().GetFilePath("crtbeginS.o")));
4728 }
4729 }
4730
4731 Args.AddAllArgs(CmdArgs, options::OPT_L);
4732 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4733 Args.AddAllArgs(CmdArgs, options::OPT_e);
4734
4735 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4736
4737 if (!Args.hasArg(options::OPT_nostdlib) &&
4738 !Args.hasArg(options::OPT_nodefaultlibs)) {
4739 if (D.CCCIsCXX) {
4740 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4741 if (Args.hasArg(options::OPT_pg))
4742 CmdArgs.push_back("-lm_p");
4743 else
4744 CmdArgs.push_back("-lm");
4745 }
4746
Rafael Espindola1ad26f02012-10-23 17:07:31 +00004747 if (Args.hasArg(options::OPT_pthread)) {
4748 if (!Args.hasArg(options::OPT_shared) &&
4749 Args.hasArg(options::OPT_pg))
4750 CmdArgs.push_back("-lpthread_p");
4751 else
4752 CmdArgs.push_back("-lpthread");
4753 }
4754
Eli Friedman9fa28852012-08-08 23:57:20 +00004755 if (!Args.hasArg(options::OPT_shared)) {
4756 if (Args.hasArg(options::OPT_pg))
4757 CmdArgs.push_back("-lc_p");
4758 else
4759 CmdArgs.push_back("-lc");
4760 }
4761
4762 std::string myarch = "-lclang_rt.";
4763 const llvm::Triple &T = getToolChain().getTriple();
4764 llvm::Triple::ArchType Arch = T.getArch();
4765 switch (Arch) {
4766 case llvm::Triple::arm:
4767 myarch += ("arm");
4768 break;
4769 case llvm::Triple::x86:
4770 myarch += ("i386");
4771 break;
4772 case llvm::Triple::x86_64:
4773 myarch += ("amd64");
4774 break;
4775 default:
4776 assert(0 && "Unsupported architecture");
4777 }
4778 CmdArgs.push_back(Args.MakeArgString(myarch));
4779 }
4780
4781 if (!Args.hasArg(options::OPT_nostdlib) &&
4782 !Args.hasArg(options::OPT_nostartfiles)) {
4783 if (!Args.hasArg(options::OPT_shared))
4784 CmdArgs.push_back(Args.MakeArgString(
4785 getToolChain().GetFilePath("crtend.o")));
4786 else
4787 CmdArgs.push_back(Args.MakeArgString(
4788 getToolChain().GetFilePath("crtendS.o")));
4789 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00004790
4791 const char *Exec =
4792 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4793 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00004794}
4795
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004796void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004797 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004798 const InputInfoList &Inputs,
4799 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00004800 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004801 ArgStringList CmdArgs;
4802
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004803 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
4804 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004805 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004806 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004807 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00004808 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004809 else if (getToolChain().getArch() == llvm::Triple::mips ||
4810 getToolChain().getArch() == llvm::Triple::mipsel ||
4811 getToolChain().getArch() == llvm::Triple::mips64 ||
4812 getToolChain().getArch() == llvm::Triple::mips64el) {
4813 StringRef CPUName;
4814 StringRef ABIName;
4815 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004816
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004817 CmdArgs.push_back("-march");
4818 CmdArgs.push_back(CPUName.data());
4819
4820 // Convert ABI name to the GNU tools acceptable variant.
4821 if (ABIName == "o32")
4822 ABIName = "32";
4823 else if (ABIName == "n64")
4824 ABIName = "64";
4825
4826 CmdArgs.push_back("-mabi");
4827 CmdArgs.push_back(ABIName.data());
4828
4829 if (getToolChain().getArch() == llvm::Triple::mips ||
4830 getToolChain().getArch() == llvm::Triple::mips64)
4831 CmdArgs.push_back("-EB");
4832 else
4833 CmdArgs.push_back("-EL");
4834
4835 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
4836 options::OPT_fpic, options::OPT_fno_pic,
4837 options::OPT_fPIE, options::OPT_fno_PIE,
4838 options::OPT_fpie, options::OPT_fno_pie);
4839 if (LastPICArg &&
4840 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
4841 LastPICArg->getOption().matches(options::OPT_fpic) ||
4842 LastPICArg->getOption().matches(options::OPT_fPIE) ||
4843 LastPICArg->getOption().matches(options::OPT_fpie))) {
4844 CmdArgs.push_back("-KPIC");
4845 }
4846 }
Eric Christopher0b26a612010-03-02 02:41:08 +00004847
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004848 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4849 options::OPT_Xassembler);
4850
4851 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004852 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004853
4854 for (InputInfoList::const_iterator
4855 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4856 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004857 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004858 }
4859
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004860 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004861 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004862 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004863}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004864
4865void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004866 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004867 const InputInfoList &Inputs,
4868 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004869 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00004870 const toolchains::FreeBSD& ToolChain =
4871 static_cast<const toolchains::FreeBSD&>(getToolChain());
4872 const Driver &D = ToolChain.getDriver();
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004873 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00004874
4875 // Silence warning for "clang -g foo.o -o foo"
4876 Args.ClaimAllArgs(options::OPT_g_Group);
4877 // and "clang -emit-llvm foo.o -o foo"
4878 Args.ClaimAllArgs(options::OPT_emit_llvm);
4879 // and for "clang -w foo.o -o foo". Other warning options are already
4880 // handled somewhere else.
4881 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004882
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00004883 if (!D.SysRoot.empty())
4884 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4885
Roman Divackyafe2f232012-08-28 15:09:03 +00004886 if (Args.hasArg(options::OPT_pie))
4887 CmdArgs.push_back("-pie");
4888
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004889 if (Args.hasArg(options::OPT_static)) {
4890 CmdArgs.push_back("-Bstatic");
4891 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00004892 if (Args.hasArg(options::OPT_rdynamic))
4893 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004894 CmdArgs.push_back("--eh-frame-hdr");
4895 if (Args.hasArg(options::OPT_shared)) {
4896 CmdArgs.push_back("-Bshareable");
4897 } else {
4898 CmdArgs.push_back("-dynamic-linker");
4899 CmdArgs.push_back("/libexec/ld-elf.so.1");
4900 }
Roman Divackyafe2f232012-08-28 15:09:03 +00004901 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
4902 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00004903 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
4904 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
4905 CmdArgs.push_back("--hash-style=both");
4906 }
4907 }
4908 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004909 }
4910
4911 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
4912 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004913 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004914 CmdArgs.push_back("-m");
4915 CmdArgs.push_back("elf_i386_fbsd");
4916 }
4917
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004918 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00004919 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00004920 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00004921 }
4922
Daniel Dunbarb440f562010-08-02 02:38:21 +00004923 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004924 CmdArgs.push_back("-o");
4925 CmdArgs.push_back(Output.getFilename());
4926 } else {
4927 assert(Output.isNothing() && "Invalid output.");
4928 }
4929
4930 if (!Args.hasArg(options::OPT_nostdlib) &&
4931 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00004932 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004933 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00004934 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00004935 crt1 = "gcrt1.o";
4936 else if (Args.hasArg(options::OPT_pie))
4937 crt1 = "Scrt1.o";
4938 else
4939 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004940 }
Roman Divackyafe2f232012-08-28 15:09:03 +00004941 if (crt1)
4942 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
4943
4944 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
4945
4946 const char *crtbegin = NULL;
4947 if (Args.hasArg(options::OPT_static))
4948 crtbegin = "crtbeginT.o";
4949 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
4950 crtbegin = "crtbeginS.o";
4951 else
4952 crtbegin = "crtbegin.o";
4953
4954 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004955 }
4956
4957 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00004958 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00004959 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
4960 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004961 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004962 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4963 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00004964 Args.AddAllArgs(CmdArgs, options::OPT_s);
4965 Args.AddAllArgs(CmdArgs, options::OPT_t);
4966 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4967 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004968
Roman Divackyafe2f232012-08-28 15:09:03 +00004969 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004970
4971 if (!Args.hasArg(options::OPT_nostdlib) &&
4972 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00004973 if (D.CCCIsCXX) {
Roman Divackyafe2f232012-08-28 15:09:03 +00004974 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00004975 if (Args.hasArg(options::OPT_pg))
4976 CmdArgs.push_back("-lm_p");
4977 else
4978 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00004979 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004980 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
4981 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00004982 if (Args.hasArg(options::OPT_pg))
4983 CmdArgs.push_back("-lgcc_p");
4984 else
4985 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004986 if (Args.hasArg(options::OPT_static)) {
4987 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00004988 } else if (Args.hasArg(options::OPT_pg)) {
4989 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004990 } else {
4991 CmdArgs.push_back("--as-needed");
4992 CmdArgs.push_back("-lgcc_s");
4993 CmdArgs.push_back("--no-as-needed");
4994 }
4995
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00004996 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00004997 if (Args.hasArg(options::OPT_pg))
4998 CmdArgs.push_back("-lpthread_p");
4999 else
5000 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005001 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005002
Roman Divacky66f22762011-02-10 16:59:40 +00005003 if (Args.hasArg(options::OPT_pg)) {
5004 if (Args.hasArg(options::OPT_shared))
5005 CmdArgs.push_back("-lc");
5006 else
5007 CmdArgs.push_back("-lc_p");
5008 CmdArgs.push_back("-lgcc_p");
5009 } else {
5010 CmdArgs.push_back("-lc");
5011 CmdArgs.push_back("-lgcc");
5012 }
5013
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005014 if (Args.hasArg(options::OPT_static)) {
5015 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005016 } else if (Args.hasArg(options::OPT_pg)) {
5017 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005018 } else {
5019 CmdArgs.push_back("--as-needed");
5020 CmdArgs.push_back("-lgcc_s");
5021 CmdArgs.push_back("--no-as-needed");
5022 }
5023 }
5024
5025 if (!Args.hasArg(options::OPT_nostdlib) &&
5026 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackya3c50242012-09-07 13:36:21 +00005027 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Roman Divackyafe2f232012-08-28 15:09:03 +00005028 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00005029 else
5030 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00005031 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005032 }
5033
Roman Divackyafe2f232012-08-28 15:09:03 +00005034 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005035
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005036 const char *Exec =
Roman Divackyafe2f232012-08-28 15:09:03 +00005037 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005038 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005039}
Daniel Dunbarcc912342009-05-02 18:28:39 +00005040
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005041void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5042 const InputInfo &Output,
5043 const InputInfoList &Inputs,
5044 const ArgList &Args,
5045 const char *LinkingOutput) const {
5046 ArgStringList CmdArgs;
5047
5048 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5049 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005050 if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005051 CmdArgs.push_back("--32");
5052
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005053 // Set byte order explicitly
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005054 if (getToolChain().getArch() == llvm::Triple::mips)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005055 CmdArgs.push_back("-EB");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005056 else if (getToolChain().getArch() == llvm::Triple::mipsel)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005057 CmdArgs.push_back("-EL");
5058
5059 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5060 options::OPT_Xassembler);
5061
5062 CmdArgs.push_back("-o");
5063 CmdArgs.push_back(Output.getFilename());
5064
5065 for (InputInfoList::const_iterator
5066 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5067 const InputInfo &II = *it;
5068 CmdArgs.push_back(II.getFilename());
5069 }
5070
David Chisnallddbd68f2011-09-27 22:03:18 +00005071 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005072 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5073}
5074
5075void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5076 const InputInfo &Output,
5077 const InputInfoList &Inputs,
5078 const ArgList &Args,
5079 const char *LinkingOutput) const {
5080 const Driver &D = getToolChain().getDriver();
5081 ArgStringList CmdArgs;
5082
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005083 if (!D.SysRoot.empty())
5084 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5085
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005086 if (Args.hasArg(options::OPT_static)) {
5087 CmdArgs.push_back("-Bstatic");
5088 } else {
5089 if (Args.hasArg(options::OPT_rdynamic))
5090 CmdArgs.push_back("-export-dynamic");
5091 CmdArgs.push_back("--eh-frame-hdr");
5092 if (Args.hasArg(options::OPT_shared)) {
5093 CmdArgs.push_back("-Bshareable");
5094 } else {
5095 CmdArgs.push_back("-dynamic-linker");
5096 CmdArgs.push_back("/libexec/ld.elf_so");
5097 }
5098 }
5099
5100 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5101 // instruct ld in the base system to link 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005102 if (getToolChain().getArch() == llvm::Triple::x86) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005103 CmdArgs.push_back("-m");
5104 CmdArgs.push_back("elf_i386");
5105 }
5106
5107 if (Output.isFilename()) {
5108 CmdArgs.push_back("-o");
5109 CmdArgs.push_back(Output.getFilename());
5110 } else {
5111 assert(Output.isNothing() && "Invalid output.");
5112 }
5113
5114 if (!Args.hasArg(options::OPT_nostdlib) &&
5115 !Args.hasArg(options::OPT_nostartfiles)) {
5116 if (!Args.hasArg(options::OPT_shared)) {
5117 CmdArgs.push_back(Args.MakeArgString(
5118 getToolChain().GetFilePath("crt0.o")));
5119 CmdArgs.push_back(Args.MakeArgString(
5120 getToolChain().GetFilePath("crti.o")));
5121 CmdArgs.push_back(Args.MakeArgString(
5122 getToolChain().GetFilePath("crtbegin.o")));
5123 } else {
5124 CmdArgs.push_back(Args.MakeArgString(
5125 getToolChain().GetFilePath("crti.o")));
5126 CmdArgs.push_back(Args.MakeArgString(
5127 getToolChain().GetFilePath("crtbeginS.o")));
5128 }
5129 }
5130
5131 Args.AddAllArgs(CmdArgs, options::OPT_L);
5132 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5133 Args.AddAllArgs(CmdArgs, options::OPT_e);
5134 Args.AddAllArgs(CmdArgs, options::OPT_s);
5135 Args.AddAllArgs(CmdArgs, options::OPT_t);
5136 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5137 Args.AddAllArgs(CmdArgs, options::OPT_r);
5138
5139 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5140
5141 if (!Args.hasArg(options::OPT_nostdlib) &&
5142 !Args.hasArg(options::OPT_nodefaultlibs)) {
5143 if (D.CCCIsCXX) {
5144 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5145 CmdArgs.push_back("-lm");
5146 }
5147 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5148 // the default system libraries. Just mimic this for now.
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005149 if (Args.hasArg(options::OPT_static)) {
5150 CmdArgs.push_back("-lgcc_eh");
5151 } else {
5152 CmdArgs.push_back("--as-needed");
5153 CmdArgs.push_back("-lgcc_s");
5154 CmdArgs.push_back("--no-as-needed");
5155 }
Joerg Sonnenberger87717772011-06-07 23:39:17 +00005156 CmdArgs.push_back("-lgcc");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005157
5158 if (Args.hasArg(options::OPT_pthread))
5159 CmdArgs.push_back("-lpthread");
5160 CmdArgs.push_back("-lc");
5161
5162 CmdArgs.push_back("-lgcc");
5163 if (Args.hasArg(options::OPT_static)) {
5164 CmdArgs.push_back("-lgcc_eh");
5165 } else {
5166 CmdArgs.push_back("--as-needed");
5167 CmdArgs.push_back("-lgcc_s");
5168 CmdArgs.push_back("--no-as-needed");
5169 }
5170 }
5171
5172 if (!Args.hasArg(options::OPT_nostdlib) &&
5173 !Args.hasArg(options::OPT_nostartfiles)) {
5174 if (!Args.hasArg(options::OPT_shared))
5175 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5176 "crtend.o")));
5177 else
5178 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5179 "crtendS.o")));
5180 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5181 "crtn.o")));
5182 }
5183
Bill Wendling08760582011-06-27 19:15:03 +00005184 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005185
David Chisnallddbd68f2011-09-27 22:03:18 +00005186 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005187 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5188}
5189
Rafael Espindola92b00932010-08-10 00:25:48 +00005190void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5191 const InputInfo &Output,
5192 const InputInfoList &Inputs,
5193 const ArgList &Args,
5194 const char *LinkingOutput) const {
5195 ArgStringList CmdArgs;
5196
5197 // Add --32/--64 to make sure we get the format we want.
5198 // This is incomplete
5199 if (getToolChain().getArch() == llvm::Triple::x86) {
5200 CmdArgs.push_back("--32");
5201 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5202 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00005203 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5204 CmdArgs.push_back("-a32");
5205 CmdArgs.push_back("-mppc");
5206 CmdArgs.push_back("-many");
5207 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5208 CmdArgs.push_back("-a64");
5209 CmdArgs.push_back("-mppc64");
5210 CmdArgs.push_back("-many");
Rafael Espindola92b00932010-08-10 00:25:48 +00005211 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005212 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00005213 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5214 CmdArgs.push_back("-mfpu=neon");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00005215
5216 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5217 getToolChain().getTriple());
5218 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00005219
5220 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5221 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5222 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005223 } else if (getToolChain().getArch() == llvm::Triple::mips ||
5224 getToolChain().getArch() == llvm::Triple::mipsel ||
5225 getToolChain().getArch() == llvm::Triple::mips64 ||
5226 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005227 StringRef CPUName;
5228 StringRef ABIName;
5229 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005230
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005231 CmdArgs.push_back("-march");
5232 CmdArgs.push_back(CPUName.data());
5233
5234 // Convert ABI name to the GNU tools acceptable variant.
5235 if (ABIName == "o32")
5236 ABIName = "32";
5237 else if (ABIName == "n64")
5238 ABIName = "64";
5239
5240 CmdArgs.push_back("-mabi");
5241 CmdArgs.push_back(ABIName.data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00005242
5243 if (getToolChain().getArch() == llvm::Triple::mips ||
5244 getToolChain().getArch() == llvm::Triple::mips64)
5245 CmdArgs.push_back("-EB");
5246 else
5247 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00005248
5249 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5250 options::OPT_fpic, options::OPT_fno_pic,
5251 options::OPT_fPIE, options::OPT_fno_PIE,
5252 options::OPT_fpie, options::OPT_fno_pie);
5253 if (LastPICArg &&
5254 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5255 LastPICArg->getOption().matches(options::OPT_fpic) ||
5256 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5257 LastPICArg->getOption().matches(options::OPT_fpie))) {
5258 CmdArgs.push_back("-KPIC");
5259 }
Rafael Espindola92b00932010-08-10 00:25:48 +00005260 }
5261
5262 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5263 options::OPT_Xassembler);
5264
5265 CmdArgs.push_back("-o");
5266 CmdArgs.push_back(Output.getFilename());
5267
5268 for (InputInfoList::const_iterator
5269 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5270 const InputInfo &II = *it;
5271 CmdArgs.push_back(II.getFilename());
5272 }
5273
5274 const char *Exec =
5275 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5276 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5277}
5278
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005279static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5280 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00005281 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Logan Chien3d3373c2012-11-19 12:04:11 +00005282 bool StaticLibgcc = Args.hasArg(options::OPT_static) ||
5283 Args.hasArg(options::OPT_static_libgcc);
Rafael Espindolacc354322011-10-17 21:39:04 +00005284 if (!D.CCCIsCXX)
5285 CmdArgs.push_back("-lgcc");
5286
Logan Chien3d3373c2012-11-19 12:04:11 +00005287 if (StaticLibgcc || isAndroid) {
Rafael Espindolacc354322011-10-17 21:39:04 +00005288 if (D.CCCIsCXX)
5289 CmdArgs.push_back("-lgcc");
5290 } else {
5291 if (!D.CCCIsCXX)
5292 CmdArgs.push_back("--as-needed");
5293 CmdArgs.push_back("-lgcc_s");
5294 if (!D.CCCIsCXX)
5295 CmdArgs.push_back("--no-as-needed");
5296 }
5297
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005298 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00005299 CmdArgs.push_back("-lgcc_eh");
5300 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
5301 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00005302
5303 // According to Android ABI, we have to link with libdl if we are
5304 // linking with non-static libgcc.
5305 //
5306 // NOTE: This fixes a link error on Android MIPS as well. The non-static
5307 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
5308 if (isAndroid && !StaticLibgcc)
5309 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00005310}
5311
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005312static bool hasMipsN32ABIArg(const ArgList &Args) {
5313 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
Richard Smithbd55daf2012-11-01 04:30:05 +00005314 return A && (A->getValue() == StringRef("n32"));
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005315}
5316
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005317void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
5318 const InputInfo &Output,
5319 const InputInfoList &Inputs,
5320 const ArgList &Args,
5321 const char *LinkingOutput) const {
5322 const toolchains::Linux& ToolChain =
5323 static_cast<const toolchains::Linux&>(getToolChain());
5324 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00005325 const bool isAndroid =
5326 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005327
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005328 ArgStringList CmdArgs;
5329
Rafael Espindolad1002f62010-11-15 18:28:16 +00005330 // Silence warning for "clang -g foo.o -o foo"
5331 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005332 // and "clang -emit-llvm foo.o -o foo"
5333 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00005334 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00005335 // handled somewhere else.
5336 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00005337
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005338 if (!D.SysRoot.empty())
5339 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005340
Rafael Espindolad47ac232010-11-17 22:26:15 +00005341 if (Args.hasArg(options::OPT_pie))
5342 CmdArgs.push_back("-pie");
5343
Rafael Espindola1c76c592010-11-07 22:57:16 +00005344 if (Args.hasArg(options::OPT_rdynamic))
5345 CmdArgs.push_back("-export-dynamic");
5346
Rafael Espindola34d77dc2010-11-11 19:34:42 +00005347 if (Args.hasArg(options::OPT_s))
5348 CmdArgs.push_back("-s");
5349
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005350 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
5351 e = ToolChain.ExtraOpts.end();
5352 i != e; ++i)
5353 CmdArgs.push_back(i->c_str());
5354
5355 if (!Args.hasArg(options::OPT_static)) {
5356 CmdArgs.push_back("--eh-frame-hdr");
5357 }
5358
5359 CmdArgs.push_back("-m");
5360 if (ToolChain.getArch() == llvm::Triple::x86)
5361 CmdArgs.push_back("elf_i386");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005362 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00005363 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005364 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005365 else if (ToolChain.getArch() == llvm::Triple::ppc)
5366 CmdArgs.push_back("elf32ppclinux");
5367 else if (ToolChain.getArch() == llvm::Triple::ppc64)
5368 CmdArgs.push_back("elf64ppc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005369 else if (ToolChain.getArch() == llvm::Triple::mips)
5370 CmdArgs.push_back("elf32btsmip");
5371 else if (ToolChain.getArch() == llvm::Triple::mipsel)
5372 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005373 else if (ToolChain.getArch() == llvm::Triple::mips64) {
5374 if (hasMipsN32ABIArg(Args))
5375 CmdArgs.push_back("elf32btsmipn32");
5376 else
5377 CmdArgs.push_back("elf64btsmip");
5378 }
5379 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
5380 if (hasMipsN32ABIArg(Args))
5381 CmdArgs.push_back("elf32ltsmipn32");
5382 else
5383 CmdArgs.push_back("elf64ltsmip");
5384 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005385 else
5386 CmdArgs.push_back("elf_x86_64");
5387
5388 if (Args.hasArg(options::OPT_static)) {
Douglas Gregord9bb1522011-03-06 19:11:49 +00005389 if (ToolChain.getArch() == llvm::Triple::arm
5390 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005391 CmdArgs.push_back("-Bstatic");
5392 else
5393 CmdArgs.push_back("-static");
5394 } else if (Args.hasArg(options::OPT_shared)) {
5395 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00005396 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005397 CmdArgs.push_back("-Bsymbolic");
5398 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005399 }
5400
5401 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00005402 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005403 (!Args.hasArg(options::OPT_static) &&
5404 !Args.hasArg(options::OPT_shared))) {
5405 CmdArgs.push_back("-dynamic-linker");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005406 if (isAndroid)
5407 CmdArgs.push_back("/system/bin/linker");
5408 else if (ToolChain.getArch() == llvm::Triple::x86)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005409 CmdArgs.push_back("/lib/ld-linux.so.2");
Douglas Gregord9bb1522011-03-06 19:11:49 +00005410 else if (ToolChain.getArch() == llvm::Triple::arm ||
Jiangning Liueabbf922012-07-30 11:05:56 +00005411 ToolChain.getArch() == llvm::Triple::thumb) {
5412 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
5413 CmdArgs.push_back("/lib/ld-linux-armhf.so.3");
5414 else
5415 CmdArgs.push_back("/lib/ld-linux.so.3");
5416 }
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005417 else if (ToolChain.getArch() == llvm::Triple::mips ||
5418 ToolChain.getArch() == llvm::Triple::mipsel)
5419 CmdArgs.push_back("/lib/ld.so.1");
Simon Atanasyan1e1e2e22012-04-06 20:14:27 +00005420 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005421 ToolChain.getArch() == llvm::Triple::mips64el) {
5422 if (hasMipsN32ABIArg(Args))
5423 CmdArgs.push_back("/lib32/ld.so.1");
5424 else
5425 CmdArgs.push_back("/lib64/ld.so.1");
5426 }
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005427 else if (ToolChain.getArch() == llvm::Triple::ppc)
Chris Lattner20b90d02011-04-11 21:15:37 +00005428 CmdArgs.push_back("/lib/ld.so.1");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005429 else if (ToolChain.getArch() == llvm::Triple::ppc64)
Chris Lattner20b90d02011-04-11 21:15:37 +00005430 CmdArgs.push_back("/lib64/ld64.so.1");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005431 else
5432 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
5433 }
5434
5435 CmdArgs.push_back("-o");
5436 CmdArgs.push_back(Output.getFilename());
5437
Rafael Espindola81937ec2010-12-01 01:52:43 +00005438 if (!Args.hasArg(options::OPT_nostdlib) &&
5439 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005440 if (!isAndroid) {
5441 const char *crt1 = NULL;
5442 if (!Args.hasArg(options::OPT_shared)){
5443 if (Args.hasArg(options::OPT_pie))
5444 crt1 = "Scrt1.o";
5445 else
5446 crt1 = "crt1.o";
5447 }
5448 if (crt1)
5449 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005450
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005451 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5452 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005453
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005454 const char *crtbegin;
5455 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005456 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005457 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005458 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005459 else if (Args.hasArg(options::OPT_pie))
5460 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005461 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005462 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005463 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00005464
5465 // Add crtfastmath.o if available and fast math is enabled.
5466 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005467 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005468
5469 Args.AddAllArgs(CmdArgs, options::OPT_L);
5470
5471 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5472
Roman Divackyee8188a2011-03-01 17:53:14 +00005473 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5474 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005475 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005476
Rafael Espindola9446d762012-04-09 23:53:34 +00005477 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5478 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5479 // forward.
5480 if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) {
5481 CmdArgs.push_back("-plugin");
5482 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5483 CmdArgs.push_back(Args.MakeArgString(Plugin));
5484 }
5485
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00005486 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5487 CmdArgs.push_back("--no-demangle");
5488
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005489 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5490
Alexey Samsonov627b10f2012-11-06 15:09:03 +00005491 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00005492
Eric Christopher04997782012-11-29 18:51:05 +00005493 // Call these before we add the C++ ABI library.
Richard Smith52be6192012-11-05 22:04:41 +00005494 if (Sanitize.needsUbsanRt())
5495 addUbsanRTLinux(getToolChain(), Args, CmdArgs);
Eric Christopher04997782012-11-29 18:51:05 +00005496 if (Sanitize.needsAsanRt())
5497 addAsanRTLinux(getToolChain(), Args, CmdArgs);
5498 if (Sanitize.needsTsanRt())
5499 addTsanRTLinux(getToolChain(), Args, CmdArgs);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00005500 if (Sanitize.needsMsanRt())
5501 addMsanRTLinux(getToolChain(), Args, CmdArgs);
Richard Smith4d3110a2012-10-25 02:14:12 +00005502
Chandler Carruth94a32012012-05-14 18:31:18 +00005503 if (D.CCCIsCXX &&
5504 !Args.hasArg(options::OPT_nostdlib) &&
5505 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00005506 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
5507 !Args.hasArg(options::OPT_static);
5508 if (OnlyLibstdcxxStatic)
5509 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005510 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00005511 if (OnlyLibstdcxxStatic)
5512 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005513 CmdArgs.push_back("-lm");
5514 }
5515
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005516 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00005517 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
5518 if (Args.hasArg(options::OPT_static))
5519 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00005520
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005521 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005522
Chandler Carruth94a32012012-05-14 18:31:18 +00005523 if (Args.hasArg(options::OPT_pthread) ||
5524 Args.hasArg(options::OPT_pthreads))
5525 CmdArgs.push_back("-lpthread");
5526
5527 CmdArgs.push_back("-lc");
5528
5529 if (Args.hasArg(options::OPT_static))
5530 CmdArgs.push_back("--end-group");
5531 else
5532 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5533 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00005534
Rafael Espindola81937ec2010-12-01 01:52:43 +00005535 if (!Args.hasArg(options::OPT_nostartfiles)) {
5536 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005537 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005538 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005539 else if (Args.hasArg(options::OPT_pie))
5540 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00005541 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005542 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005543
Rafael Espindola81937ec2010-12-01 01:52:43 +00005544 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005545 if (!isAndroid)
5546 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00005547 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005548 }
5549
Bill Wendling08760582011-06-27 19:15:03 +00005550 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005551
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005552 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
5553}
Rafael Espindola92b00932010-08-10 00:25:48 +00005554
Chris Lattner3e2ee142010-07-07 16:01:42 +00005555void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005556 const InputInfo &Output,
5557 const InputInfoList &Inputs,
5558 const ArgList &Args,
5559 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005560 ArgStringList CmdArgs;
5561
5562 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5563 options::OPT_Xassembler);
5564
5565 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005566 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00005567
5568 for (InputInfoList::const_iterator
5569 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5570 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005571 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00005572 }
5573
5574 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00005575 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005576 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005577}
5578
5579void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005580 const InputInfo &Output,
5581 const InputInfoList &Inputs,
5582 const ArgList &Args,
5583 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005584 const Driver &D = getToolChain().getDriver();
5585 ArgStringList CmdArgs;
5586
Daniel Dunbarb440f562010-08-02 02:38:21 +00005587 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005588 CmdArgs.push_back("-o");
5589 CmdArgs.push_back(Output.getFilename());
5590 } else {
5591 assert(Output.isNothing() && "Invalid output.");
5592 }
5593
5594 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00005595 !Args.hasArg(options::OPT_nostartfiles)) {
5596 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
5597 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5598 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
5599 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
5600 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005601
5602 Args.AddAllArgs(CmdArgs, options::OPT_L);
5603 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5604 Args.AddAllArgs(CmdArgs, options::OPT_e);
5605
Daniel Dunbar54423b22010-09-17 00:24:54 +00005606 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00005607
Eli Friedman83de5132011-12-08 23:54:21 +00005608 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5609
Chris Lattner3e2ee142010-07-07 16:01:42 +00005610 if (!Args.hasArg(options::OPT_nostdlib) &&
5611 !Args.hasArg(options::OPT_nodefaultlibs)) {
5612 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005613 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00005614 CmdArgs.push_back("-lm");
5615 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005616 }
5617
5618 if (!Args.hasArg(options::OPT_nostdlib) &&
5619 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00005620 if (Args.hasArg(options::OPT_pthread))
5621 CmdArgs.push_back("-lpthread");
5622 CmdArgs.push_back("-lc");
5623 CmdArgs.push_back("-lCompilerRT-Generic");
5624 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
5625 CmdArgs.push_back(
5626 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005627 }
5628
Eli Friedman83de5132011-12-08 23:54:21 +00005629 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005630 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005631}
5632
Daniel Dunbarcc912342009-05-02 18:28:39 +00005633/// DragonFly Tools
5634
5635// For now, DragonFly Assemble does just about the same as for
5636// FreeBSD, but this may change soon.
5637void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005638 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005639 const InputInfoList &Inputs,
5640 const ArgList &Args,
5641 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005642 ArgStringList CmdArgs;
5643
5644 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5645 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005646 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00005647 CmdArgs.push_back("--32");
5648
5649 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5650 options::OPT_Xassembler);
5651
5652 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005653 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00005654
5655 for (InputInfoList::const_iterator
5656 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5657 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005658 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00005659 }
5660
5661 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005662 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005663 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005664}
5665
5666void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005667 const InputInfo &Output,
5668 const InputInfoList &Inputs,
5669 const ArgList &Args,
5670 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005671 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00005672 ArgStringList CmdArgs;
5673
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005674 if (!D.SysRoot.empty())
5675 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5676
Daniel Dunbarcc912342009-05-02 18:28:39 +00005677 if (Args.hasArg(options::OPT_static)) {
5678 CmdArgs.push_back("-Bstatic");
5679 } else {
5680 if (Args.hasArg(options::OPT_shared))
5681 CmdArgs.push_back("-Bshareable");
5682 else {
5683 CmdArgs.push_back("-dynamic-linker");
5684 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
5685 }
5686 }
5687
5688 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5689 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005690 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005691 CmdArgs.push_back("-m");
5692 CmdArgs.push_back("elf_i386");
5693 }
5694
Daniel Dunbarb440f562010-08-02 02:38:21 +00005695 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005696 CmdArgs.push_back("-o");
5697 CmdArgs.push_back(Output.getFilename());
5698 } else {
5699 assert(Output.isNothing() && "Invalid output.");
5700 }
5701
5702 if (!Args.hasArg(options::OPT_nostdlib) &&
5703 !Args.hasArg(options::OPT_nostartfiles)) {
5704 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005705 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005706 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005707 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005708 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005709 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005710 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005711 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005712 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005713 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005714 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005715 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005716 }
5717 }
5718
5719 Args.AddAllArgs(CmdArgs, options::OPT_L);
5720 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5721 Args.AddAllArgs(CmdArgs, options::OPT_e);
5722
Daniel Dunbar54423b22010-09-17 00:24:54 +00005723 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00005724
5725 if (!Args.hasArg(options::OPT_nostdlib) &&
5726 !Args.hasArg(options::OPT_nodefaultlibs)) {
5727 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
5728 // rpaths
5729 CmdArgs.push_back("-L/usr/lib/gcc41");
5730
5731 if (!Args.hasArg(options::OPT_static)) {
5732 CmdArgs.push_back("-rpath");
5733 CmdArgs.push_back("/usr/lib/gcc41");
5734
5735 CmdArgs.push_back("-rpath-link");
5736 CmdArgs.push_back("/usr/lib/gcc41");
5737
5738 CmdArgs.push_back("-rpath");
5739 CmdArgs.push_back("/usr/lib");
5740
5741 CmdArgs.push_back("-rpath-link");
5742 CmdArgs.push_back("/usr/lib");
5743 }
5744
Rafael Espindola38360b32010-07-20 12:59:03 +00005745 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005746 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00005747 CmdArgs.push_back("-lm");
5748 }
5749
Daniel Dunbarcc912342009-05-02 18:28:39 +00005750 if (Args.hasArg(options::OPT_shared)) {
5751 CmdArgs.push_back("-lgcc_pic");
5752 } else {
5753 CmdArgs.push_back("-lgcc");
5754 }
5755
5756
5757 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00005758 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00005759
5760 if (!Args.hasArg(options::OPT_nolibc)) {
5761 CmdArgs.push_back("-lc");
5762 }
5763
5764 if (Args.hasArg(options::OPT_shared)) {
5765 CmdArgs.push_back("-lgcc_pic");
5766 } else {
5767 CmdArgs.push_back("-lgcc");
5768 }
5769 }
5770
5771 if (!Args.hasArg(options::OPT_nostdlib) &&
5772 !Args.hasArg(options::OPT_nostartfiles)) {
5773 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005774 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005775 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005776 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005777 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005778 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005779 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005780 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005781 }
5782
Bill Wendling08760582011-06-27 19:15:03 +00005783 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005784
Daniel Dunbarcc912342009-05-02 18:28:39 +00005785 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005786 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005787 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005788}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00005789
5790void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
5791 const InputInfo &Output,
5792 const InputInfoList &Inputs,
5793 const ArgList &Args,
5794 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00005795 ArgStringList CmdArgs;
5796
5797 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00005798 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
5799 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00005800 } else {
5801 assert(Output.isNothing() && "Invalid output.");
5802 }
5803
5804 if (!Args.hasArg(options::OPT_nostdlib) &&
5805 !Args.hasArg(options::OPT_nostartfiles)) {
5806 CmdArgs.push_back("-defaultlib:libcmt");
5807 }
5808
5809 CmdArgs.push_back("-nologo");
5810
Michael J. Spencere2f49362012-06-18 16:56:04 +00005811 Args.AddAllArgValues(CmdArgs, options::OPT_l);
5812
5813 // Add filenames immediately.
5814 for (InputInfoList::const_iterator
5815 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5816 if (it->isFilename())
5817 CmdArgs.push_back(it->getFilename());
5818 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00005819
5820 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00005821 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00005822 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5823}