blob: 0cc9ea2537349bc91fbe7a671fa3698372b21d06 [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"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000015#include "clang/Basic/Version.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000016#include "clang/Driver/Action.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000017#include "clang/Driver/Arg.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000018#include "clang/Driver/ArgList.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000019#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000020#include "clang/Driver/Driver.h"
21#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000022#include "clang/Driver/Job.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000023#include "clang/Driver/Option.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000024#include "clang/Driver/Options.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000025#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000026#include "clang/Driver/Util.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000027#include "llvm/ADT/SmallString.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000028#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000029#include "llvm/ADT/Twine.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000030#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000031#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000032#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000033#include "llvm/Support/Host.h"
34#include "llvm/Support/Process.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000035#include "llvm/Support/raw_ostream.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000036
Daniel Dunbar1a093d22009-03-18 06:00:36 +000037using namespace clang::driver;
38using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000039using namespace clang;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000040
Daniel Dunbar64198ef2009-09-10 01:21:05 +000041/// CheckPreprocessingOptions - Perform some validation of preprocessing
42/// arguments that is shared with gcc.
43static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
44 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +000045 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
Chris Lattner0e62c1c2011-07-23 10:55:15 +000046 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar64198ef2009-09-10 01:21:05 +000047 << A->getAsString(Args) << "-E";
48}
49
Daniel Dunbar4eadb602009-09-10 01:21:12 +000050/// CheckCodeGenerationOptions - Perform some validation of code generation
51/// arguments that is shared with gcc.
52static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
53 // In gcc, only ARM checks this, but it seems reasonable to check universally.
54 if (Args.hasArg(options::OPT_static))
55 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
56 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000057 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000058 << A->getAsString(Args) << "-static";
59}
60
Chris Lattnerbf2803f2010-03-29 17:55:58 +000061// Quote target names for inclusion in GNU Make dependency files.
62// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000063static void QuoteTarget(StringRef Target,
64 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000065 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
66 switch (Target[i]) {
67 case ' ':
68 case '\t':
69 // Escape the preceding backslashes
70 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
71 Res.push_back('\\');
72
73 // Escape the space/tab
74 Res.push_back('\\');
75 break;
76 case '$':
77 Res.push_back('$');
78 break;
79 case '#':
80 Res.push_back('\\');
81 break;
82 default:
83 break;
84 }
85
86 Res.push_back(Target[i]);
87 }
88}
89
Bill Wendlingc0938f32012-03-12 22:10:06 +000090static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +000091 ArgStringList &CmdArgs,
92 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +000093 const char *EnvVar) {
94 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +000095 bool CombinedArg = false;
96
Bill Wendling281ca292012-03-12 21:22:35 +000097 if (!DirList)
98 return; // Nothing to do.
99
Chad Rosier616e8a52012-10-30 21:42:09 +0000100 StringRef Name(ArgName);
101 if (Name.equals("-I") || Name.equals("-L"))
102 CombinedArg = true;
103
Bill Wendling281ca292012-03-12 21:22:35 +0000104 StringRef Dirs(DirList);
105 if (Dirs.empty()) // Empty string should not add '.'.
106 return;
107
108 StringRef::size_type Delim;
109 while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
110 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000111 if (CombinedArg) {
112 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
113 } else {
114 CmdArgs.push_back(ArgName);
115 CmdArgs.push_back(".");
116 }
Bill Wendling281ca292012-03-12 21:22:35 +0000117 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000118 if (CombinedArg) {
119 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
120 } else {
121 CmdArgs.push_back(ArgName);
122 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
123 }
Bill Wendling281ca292012-03-12 21:22:35 +0000124 }
Nico Weber89355782012-03-19 15:00:03 +0000125 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000126 }
127
128 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000129 if (CombinedArg) {
130 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
131 } else {
132 CmdArgs.push_back(ArgName);
133 CmdArgs.push_back(".");
134 }
Bill Wendling281ca292012-03-12 21:22:35 +0000135 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000136 if (CombinedArg) {
137 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
138 } else {
139 CmdArgs.push_back(ArgName);
140 CmdArgs.push_back(Args.MakeArgString(Dirs));
141 }
Bill Wendling281ca292012-03-12 21:22:35 +0000142 }
143}
144
Daniel Dunbar54423b22010-09-17 00:24:54 +0000145static void AddLinkerInputs(const ToolChain &TC,
146 const InputInfoList &Inputs, const ArgList &Args,
147 ArgStringList &CmdArgs) {
148 const Driver &D = TC.getDriver();
149
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000150 // Add extra linker input arguments which are not treated as inputs
151 // (constructed via -Xarch_).
152 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
153
Daniel Dunbar54423b22010-09-17 00:24:54 +0000154 for (InputInfoList::const_iterator
155 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
156 const InputInfo &II = *it;
157
158 if (!TC.HasNativeLLVMSupport()) {
159 // Don't try to pass LLVM inputs unless we have native support.
160 if (II.getType() == types::TY_LLVM_IR ||
161 II.getType() == types::TY_LTO_IR ||
162 II.getType() == types::TY_LLVM_BC ||
163 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000164 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000165 << TC.getTripleString();
166 }
167
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000168 // Add filenames immediately.
169 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000170 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000171 continue;
172 }
173
174 // Otherwise, this is a linker input argument.
175 const Arg &A = II.getInputArg();
176
177 // Handle reserved library options.
178 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000179 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000180 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
181 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000182 } else
183 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000184 }
Bill Wendling281ca292012-03-12 21:22:35 +0000185
186 // LIBRARY_PATH - included following the user specified library paths.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000187 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000188}
189
John McCall31168b02011-06-15 23:02:42 +0000190/// \brief Determine whether Objective-C automated reference counting is
191/// enabled.
192static bool isObjCAutoRefCount(const ArgList &Args) {
193 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
194}
195
Ted Kremeneke65b0862012-03-06 20:05:56 +0000196/// \brief Determine whether we are linking the ObjC runtime.
197static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000198 if (isObjCAutoRefCount(Args)) {
199 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000200 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000201 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000202 return Args.hasArg(options::OPT_fobjc_link_runtime);
203}
204
Rafael Espindola9d4a8cf2011-06-02 18:58:46 +0000205static void addProfileRT(const ToolChain &TC, const ArgList &Args,
Bill Wendling08760582011-06-27 19:15:03 +0000206 ArgStringList &CmdArgs,
207 llvm::Triple Triple) {
208 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
209 Args.hasArg(options::OPT_fprofile_generate) ||
210 Args.hasArg(options::OPT_fcreate_profile) ||
211 Args.hasArg(options::OPT_coverage)))
212 return;
213
214 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
215 // the link line. We cannot do the same thing because unlike gcov there is a
216 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
217 // not supported by old linkers.
Benjamin Kramerf5fbe432011-11-07 16:02:25 +0000218 std::string ProfileRT =
219 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
Bill Wendling08760582011-06-27 19:15:03 +0000220
Bill Wendling08760582011-06-27 19:15:03 +0000221 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
Rafael Espindola9d4a8cf2011-06-02 18:58:46 +0000222}
223
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000224static bool forwardToGCC(const Option &O) {
225 return !O.hasFlag(options::NoForward) &&
226 !O.hasFlag(options::DriverOption) &&
227 !O.hasFlag(options::LinkerInput);
228}
229
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000230void Clang::AddPreprocessingOptions(Compilation &C,
231 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000232 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000233 ArgStringList &CmdArgs,
234 const InputInfo &Output,
235 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000236 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000237
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000238 CheckPreprocessingOptions(D, Args);
239
240 Args.AddLastArg(CmdArgs, options::OPT_C);
241 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000242
243 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000244 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000245 (A = Args.getLastArg(options::OPT_MD)) ||
246 (A = Args.getLastArg(options::OPT_MMD))) {
247 // Determine the output location.
248 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000249 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000250 DepFile = MF->getValue();
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000251 C.addFailureResultFile(DepFile);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000252 } else if (Output.getType() == types::TY_Dependencies) {
253 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000254 } else if (A->getOption().matches(options::OPT_M) ||
255 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000256 DepFile = "-";
257 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000258 DepFile = getDependencyFileName(Args, Inputs);
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000259 C.addFailureResultFile(DepFile);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000260 }
261 CmdArgs.push_back("-dependency-file");
262 CmdArgs.push_back(DepFile);
263
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000264 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000265 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
266 const char *DepTarget;
267
268 // If user provided -o, that is the dependency target, except
269 // when we are only generating a dependency file.
270 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
271 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000272 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000273 } else {
274 // Otherwise derive from the base input.
275 //
276 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000277 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000278 llvm::sys::path::replace_extension(P, "o");
279 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000280 }
281
282 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000283 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000284 QuoteTarget(DepTarget, Quoted);
285 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000286 }
287
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000288 if (A->getOption().matches(options::OPT_M) ||
289 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000290 CmdArgs.push_back("-sys-header-deps");
291 }
292
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000293 if (Args.hasArg(options::OPT_MG)) {
294 if (!A || A->getOption().matches(options::OPT_MD) ||
295 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000296 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000297 CmdArgs.push_back("-MG");
298 }
299
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000300 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000301
302 // Convert all -MQ <target> args to -MT <quoted target>
303 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
304 options::OPT_MQ),
305 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000306 const Arg *A = *it;
307 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000308
Daniel Dunbara442fd52010-06-11 22:00:13 +0000309 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000310 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000311 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000312 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000313 CmdArgs.push_back(Args.MakeArgString(Quoted));
314
315 // -MT flag - no change
316 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000317 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000318 }
319 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000320
Douglas Gregor111af7d2009-04-18 00:34:01 +0000321 // Add -i* options, and automatically translate to
322 // -include-pch/-include-pth for transparent PCH support. It's
323 // wonky, but we include looking for .gch so we can support seamless
324 // replacement into a build system already set up to be generating
325 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000326 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000327 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
328 ie = Args.filtered_end(); it != ie; ++it) {
329 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000330
331 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000332 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
333 RenderedImplicitInclude = true;
334
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000335 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000336 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000337
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000338 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000339 bool FoundPCH = false;
Richard Smithbd55daf2012-11-01 04:30:05 +0000340 llvm::sys::Path P(A->getValue());
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000341 bool Exists;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000342 if (UsePCH) {
Douglas Gregor111af7d2009-04-18 00:34:01 +0000343 P.appendSuffix("pch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000344 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000345 FoundPCH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000346 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000347 P.eraseSuffix();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000348 }
349
Douglas Gregor111af7d2009-04-18 00:34:01 +0000350 if (!FoundPCH) {
351 P.appendSuffix("pth");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000352 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000353 FoundPTH = true;
354 else
355 P.eraseSuffix();
Mike Stump11289f42009-09-09 15:08:12 +0000356 }
357
Douglas Gregor111af7d2009-04-18 00:34:01 +0000358 if (!FoundPCH && !FoundPTH) {
359 P.appendSuffix("gch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000360 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000361 FoundPCH = UsePCH;
362 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000363 }
Mike Stump11289f42009-09-09 15:08:12 +0000364 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000365 P.eraseSuffix();
366 }
367
368 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000369 if (IsFirstImplicitInclude) {
370 A->claim();
371 if (UsePCH)
372 CmdArgs.push_back("-include-pch");
373 else
374 CmdArgs.push_back("-include-pth");
375 CmdArgs.push_back(Args.MakeArgString(P.str()));
376 continue;
377 } else {
378 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000379 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000380 << P.str() << A->getAsString(Args);
381 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000382 }
383 }
384
385 // Not translated, render as usual.
386 A->claim();
387 A->render(Args, CmdArgs);
388 }
389
390 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000391 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
392 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000393
394 // Add -Wp, and -Xassembler if using the preprocessor.
395
396 // FIXME: There is a very unfortunate problem here, some troubled
397 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
398 // really support that we would have to parse and then translate
399 // those options. :(
400 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
401 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000402
403 // -I- is a deprecated GCC feature, reject it.
404 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000405 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000406
407 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
408 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000409 StringRef sysroot = C.getSysRoot();
410 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000411 if (!Args.hasArg(options::OPT_isysroot)) {
412 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000413 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000414 }
415 }
Douglas Gregorf936f782011-09-14 20:28:46 +0000416
417 // If a module path was provided, pass it along. Otherwise, use a temporary
418 // directory.
419 if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) {
Douglas Gregorf936f782011-09-14 20:28:46 +0000420 A->claim();
421 A->render(Args, CmdArgs);
422 } else {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000423 SmallString<128> DefaultModuleCache;
Douglas Gregorf936f782011-09-14 20:28:46 +0000424 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
425 DefaultModuleCache);
426 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
427 CmdArgs.push_back("-fmodule-cache-path");
428 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
429 }
Douglas Gregor97eec242011-09-15 22:00:41 +0000430
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000431 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000432 // FIXME: We should probably sink the logic for handling these from the
433 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000434 // CPATH - included following the user specified includes (but prior to
435 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000436 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000437 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000438 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000439 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000440 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000441 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000442 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000443 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000444 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000445
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000446 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000447 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000448 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000449
450 // Add system include arguments.
451 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000452}
453
Daniel Dunbarf492c922009-09-10 22:59:51 +0000454/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000455/// CPU.
456//
457// FIXME: This is redundant with -mcpu, why does LLVM use this.
458// FIXME: tblgen this, or kill it!
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000459static const char *getLLVMArchSuffixForARM(StringRef CPU) {
Chad Rosier9ac84512011-10-07 17:48:56 +0000460 return llvm::StringSwitch<const char *>(CPU)
461 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
462 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
463 .Cases("arm920", "arm920t", "arm922t", "v4t")
464 .Cases("arm940t", "ep9312","v4t")
465 .Cases("arm10tdmi", "arm1020t", "v5")
466 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
467 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
468 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
469 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
470 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
471 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Quentin Colombet2e9952e2012-11-29 23:15:27 +0000472 .Cases("cortex-a5", "cortex-a8", "cortex-a9", "cortex-a15", "v7")
Quentin Colombetf5a37a32012-12-21 17:57:47 +0000473 .Case("cortex-r5", "v7r")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000474 .Case("cortex-m3", "v7m")
Jim Grosbach903e63f2012-03-29 19:53:34 +0000475 .Case("cortex-m4", "v7m")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000476 .Case("cortex-m0", "v6m")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000477 .Case("cortex-a9-mp", "v7f")
478 .Case("swift", "v7s")
Chad Rosier9ac84512011-10-07 17:48:56 +0000479 .Default("");
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000480}
481
Benjamin Kramer09811c72012-06-26 22:20:06 +0000482/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
483//
484// FIXME: tblgen this.
485static std::string getARMTargetCPU(const ArgList &Args,
486 const llvm::Triple &Triple) {
487 // FIXME: Warn on inconsistent use of -mcpu and -march.
488
489 // If we have -mcpu=, use that.
490 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000491 StringRef MCPU = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000492 // Handle -mcpu=native.
493 if (MCPU == "native")
494 return llvm::sys::getHostCPUName();
495 else
496 return MCPU;
497 }
498
499 StringRef MArch;
500 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
501 // Otherwise, if we have -march= choose the base CPU for that arch.
Richard Smithbd55daf2012-11-01 04:30:05 +0000502 MArch = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000503 } else {
504 // Otherwise, use the Arch from the triple.
505 MArch = Triple.getArchName();
506 }
507
508 // Handle -march=native.
509 std::string NativeMArch;
510 if (MArch == "native") {
511 std::string CPU = llvm::sys::getHostCPUName();
512 if (CPU != "generic") {
513 // Translate the native cpu into the architecture. The switch below will
514 // then chose the minimum cpu for that arch.
515 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
516 MArch = NativeMArch;
517 }
518 }
519
520 return llvm::StringSwitch<const char *>(MArch)
521 .Cases("armv2", "armv2a","arm2")
522 .Case("armv3", "arm6")
523 .Case("armv3m", "arm7m")
524 .Cases("armv4", "armv4t", "arm7tdmi")
525 .Cases("armv5", "armv5t", "arm10tdmi")
526 .Cases("armv5e", "armv5te", "arm1022e")
527 .Case("armv5tej", "arm926ej-s")
528 .Cases("armv6", "armv6k", "arm1136jf-s")
529 .Case("armv6j", "arm1136j-s")
530 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
531 .Case("armv6t2", "arm1156t2-s")
532 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000533 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
534 .Cases("armv7s", "armv7-s", "swift")
Benjamin Kramer09811c72012-06-26 22:20:06 +0000535 .Cases("armv7r", "armv7-r", "cortex-r4")
536 .Cases("armv7m", "armv7-m", "cortex-m3")
537 .Case("ep9312", "ep9312")
538 .Case("iwmmxt", "iwmmxt")
539 .Case("xscale", "xscale")
540 .Cases("armv6m", "armv6-m", "cortex-m0")
541 // If all else failed, return the most base CPU LLVM supports.
542 .Default("arm7tdmi");
543}
544
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000545// FIXME: Move to target hook.
546static bool isSignedCharDefault(const llvm::Triple &Triple) {
547 switch (Triple.getArch()) {
548 default:
549 return true;
550
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000551 case llvm::Triple::arm:
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000552 case llvm::Triple::ppc:
553 case llvm::Triple::ppc64:
Bob Wilson6524dd32011-10-14 05:03:44 +0000554 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000555 return true;
556 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000557 }
558}
559
Chad Rosiercfbfc582012-04-04 20:51:35 +0000560// Handle -mfpu=.
561//
562// FIXME: Centralize feature selection, defaulting shouldn't be also in the
563// frontend target.
564static void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args,
565 ArgStringList &CmdArgs) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000566 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000567
568 // Set the target features based on the FPU.
569 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
570 // Disable any default FPU support.
571 CmdArgs.push_back("-target-feature");
572 CmdArgs.push_back("-vfp2");
573 CmdArgs.push_back("-target-feature");
574 CmdArgs.push_back("-vfp3");
575 CmdArgs.push_back("-target-feature");
576 CmdArgs.push_back("-neon");
577 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
578 CmdArgs.push_back("-target-feature");
579 CmdArgs.push_back("+vfp3");
580 CmdArgs.push_back("-target-feature");
581 CmdArgs.push_back("+d16");
582 CmdArgs.push_back("-target-feature");
583 CmdArgs.push_back("-neon");
584 } else if (FPU == "vfp") {
585 CmdArgs.push_back("-target-feature");
586 CmdArgs.push_back("+vfp2");
587 CmdArgs.push_back("-target-feature");
588 CmdArgs.push_back("-neon");
589 } else if (FPU == "vfp3" || FPU == "vfpv3") {
590 CmdArgs.push_back("-target-feature");
591 CmdArgs.push_back("+vfp3");
592 CmdArgs.push_back("-target-feature");
593 CmdArgs.push_back("-neon");
594 } else if (FPU == "neon") {
595 CmdArgs.push_back("-target-feature");
596 CmdArgs.push_back("+neon");
597 } else
598 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
599}
600
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000601// Handle -mfpmath=.
602static void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args,
Chad Rosier45619cb2012-04-04 22:13:40 +0000603 ArgStringList &CmdArgs, StringRef CPU) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000604 StringRef FPMath = A->getValue();
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000605
606 // Set the target features based on the FPMath.
607 if (FPMath == "neon") {
608 CmdArgs.push_back("-target-feature");
609 CmdArgs.push_back("+neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000610
Silviu Baranga157f7c62012-09-13 15:06:00 +0000611 if (CPU != "cortex-a8" && CPU != "cortex-a9" && CPU != "cortex-a9-mp" &&
Quentin Colombet2e9952e2012-11-29 23:15:27 +0000612 CPU != "cortex-a15" && CPU != "cortex-a5")
Chad Rosier45619cb2012-04-04 22:13:40 +0000613 D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU;
614
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000615 } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" ||
616 FPMath == "vfp4") {
617 CmdArgs.push_back("-target-feature");
618 CmdArgs.push_back("-neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000619
620 // FIXME: Add warnings when disabling a feature not present for a given CPU.
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000621 } else
622 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
623}
624
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000625// Select the float ABI as determined by -msoft-float, -mhard-float, and
626// -mfloat-abi=.
627static StringRef getARMFloatABI(const Driver &D,
628 const ArgList &Args,
629 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000630 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000631 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
632 options::OPT_mhard_float,
633 options::OPT_mfloat_abi_EQ)) {
634 if (A->getOption().matches(options::OPT_msoft_float))
635 FloatABI = "soft";
636 else if (A->getOption().matches(options::OPT_mhard_float))
637 FloatABI = "hard";
638 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000639 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000640 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000641 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000642 << A->getAsString(Args);
643 FloatABI = "soft";
644 }
645 }
646 }
647
648 // If unspecified, choose the default based on the platform.
649 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000650 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000651 case llvm::Triple::Darwin:
652 case llvm::Triple::MacOSX:
653 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000654 // Darwin defaults to "softfp" for v6 and v7.
655 //
656 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000657 std::string ArchName =
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000658 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000659 if (StringRef(ArchName).startswith("v6") ||
660 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000661 FloatABI = "softfp";
662 else
663 FloatABI = "soft";
664 break;
665 }
666
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000667 case llvm::Triple::FreeBSD:
668 // FreeBSD defaults to soft float
669 FloatABI = "soft";
670 break;
671
Daniel Dunbar78485922009-09-10 23:00:09 +0000672 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000673 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000674 case llvm::Triple::GNUEABIHF:
675 FloatABI = "hard";
676 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000677 case llvm::Triple::GNUEABI:
678 FloatABI = "softfp";
679 break;
680 case llvm::Triple::EABI:
681 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
682 FloatABI = "softfp";
683 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000684 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000685 std::string ArchName =
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000686 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000687 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000688 FloatABI = "softfp";
689 else
690 FloatABI = "soft";
691 break;
692 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000693 default:
694 // Assume "soft", but warn the user we are guessing.
695 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000696 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000697 break;
698 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000699 }
700 }
701
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000702 return FloatABI;
703}
704
705
706void Clang::AddARMTargetArgs(const ArgList &Args,
707 ArgStringList &CmdArgs,
708 bool KernelOrKext) const {
709 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000710 // Get the effective triple, which takes into account the deployment target.
711 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
712 llvm::Triple Triple(TripleStr);
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000713 std::string CPUName = getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000714
715 // Select the ABI to use.
716 //
717 // FIXME: Support -meabi.
718 const char *ABIName = 0;
719 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000720 ABIName = A->getValue();
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000721 } else if (Triple.isOSDarwin()) {
722 // The backend is hardwired to assume AAPCS for M-class processors, ensure
723 // the frontend matches that.
724 if (StringRef(CPUName).startswith("cortex-m")) {
725 ABIName = "aapcs";
726 } else {
727 ABIName = "apcs-gnu";
728 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000729 } else {
730 // Select the default based on the platform.
731 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000732 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000733 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000734 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000735 ABIName = "aapcs-linux";
736 break;
737 case llvm::Triple::EABI:
738 ABIName = "aapcs";
739 break;
740 default:
741 ABIName = "apcs-gnu";
742 }
743 }
744 CmdArgs.push_back("-target-abi");
745 CmdArgs.push_back(ABIName);
746
747 // Set the CPU based on -march= and -mcpu=.
748 CmdArgs.push_back("-target-cpu");
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000749 CmdArgs.push_back(Args.MakeArgString(CPUName));
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000750
751 // Determine floating point ABI from the options & target defaults.
752 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000753 if (FloatABI == "soft") {
754 // Floating point operations and argument passing are soft.
755 //
756 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000757 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000758 CmdArgs.push_back("-mfloat-abi");
759 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000760 } else if (FloatABI == "softfp") {
761 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000762 CmdArgs.push_back("-mfloat-abi");
763 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000764 } else {
765 // Floating point operations and argument passing are hard.
766 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000767 CmdArgs.push_back("-mfloat-abi");
768 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000769 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000770
771 // Set appropriate target features for floating point mode.
772 //
773 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
774 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
775 // stripped out by the ARM target.
776
777 // Use software floating point operations?
778 if (FloatABI == "soft") {
779 CmdArgs.push_back("-target-feature");
780 CmdArgs.push_back("+soft-float");
781 }
782
783 // Use software floating point argument passing?
784 if (FloatABI != "hard") {
785 CmdArgs.push_back("-target-feature");
786 CmdArgs.push_back("+soft-float-abi");
787 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +0000788
789 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +0000790 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +0000791 addFPUArgs(D, A, Args, CmdArgs);
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000792
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000793 // Honor -mfpmath=.
794 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +0000795 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000796
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000797 // Setting -msoft-float effectively disables NEON because of the GCC
798 // implementation, although the same isn't true of VFP or VFP3.
799 if (FloatABI == "soft") {
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000800 CmdArgs.push_back("-target-feature");
801 CmdArgs.push_back("-neon");
802 }
803
804 // Kernel code has more strict alignment requirements.
805 if (KernelOrKext) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000806 if (Triple.getOS() != llvm::Triple::IOS || Triple.isOSVersionLT(6)) {
807 CmdArgs.push_back("-backend-option");
808 CmdArgs.push_back("-arm-long-calls");
809 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000810
Daniel Dunbar12100e22011-03-22 16:48:17 +0000811 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000812 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000813
814 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000815 CmdArgs.push_back("-backend-option");
816 CmdArgs.push_back("-arm-darwin-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000817 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000818
819 // Setting -mno-global-merge disables the codegen global merge pass. Setting
820 // -mglobal-merge has no effect as the pass is enabled by default.
821 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
822 options::OPT_mno_global_merge)) {
823 if (A->getOption().matches(options::OPT_mno_global_merge))
824 CmdArgs.push_back("-mno-global-merge");
825 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000826
Chad Rosierc14ded72012-05-16 21:19:55 +0000827 if (Args.hasArg(options::OPT_mno_implicit_float))
Chad Rosierf1985d22012-05-16 20:40:09 +0000828 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000829}
830
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000831// Translate MIPS CPU name alias option to CPU name.
832static StringRef getMipsCPUFromAlias(const Arg &A) {
833 if (A.getOption().matches(options::OPT_mips32))
834 return "mips32";
835 if (A.getOption().matches(options::OPT_mips32r2))
836 return "mips32r2";
837 if (A.getOption().matches(options::OPT_mips64))
838 return "mips64";
839 if (A.getOption().matches(options::OPT_mips64r2))
840 return "mips64r2";
841 llvm_unreachable("Unexpected option");
842 return "";
843}
844
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000845// Get CPU and ABI names. They are not independent
846// so we have to calculate them together.
847static void getMipsCPUAndABI(const ArgList &Args,
848 const ToolChain &TC,
849 StringRef &CPUName,
850 StringRef &ABIName) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000851 const char *DefMips32CPU = "mips32";
852 const char *DefMips64CPU = "mips64";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000853
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000854 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000855 options::OPT_mcpu_EQ,
856 options::OPT_mips_CPUs_Group)) {
857 if (A->getOption().matches(options::OPT_mips_CPUs_Group))
858 CPUName = getMipsCPUFromAlias(*A);
859 else
Richard Smithbd55daf2012-11-01 04:30:05 +0000860 CPUName = A->getValue();
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000861 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000862
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000863 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000864 ABIName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000865
866 // Setup default CPU and ABI names.
867 if (CPUName.empty() && ABIName.empty()) {
868 switch (TC.getTriple().getArch()) {
869 default:
870 llvm_unreachable("Unexpected triple arch name");
871 case llvm::Triple::mips:
872 case llvm::Triple::mipsel:
873 CPUName = DefMips32CPU;
874 break;
875 case llvm::Triple::mips64:
876 case llvm::Triple::mips64el:
877 CPUName = DefMips64CPU;
878 break;
879 }
880 }
881
882 if (!ABIName.empty()) {
883 // Deduce CPU name from ABI name.
884 CPUName = llvm::StringSwitch<const char *>(ABIName)
885 .Cases("o32", "eabi", DefMips32CPU)
886 .Cases("n32", "n64", DefMips64CPU)
887 .Default("");
888 }
889 else if (!CPUName.empty()) {
890 // Deduce ABI name from CPU name.
891 ABIName = llvm::StringSwitch<const char *>(CPUName)
892 .Cases("mips32", "mips32r2", "o32")
893 .Cases("mips64", "mips64r2", "n64")
894 .Default("");
895 }
896
897 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000898}
899
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000900// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
901// and -mfloat-abi=.
902static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000903 // Select the float ABI as determined by -msoft-float, -mhard-float,
904 // and -mfloat-abi=.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000905 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000906 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000907 options::OPT_mhard_float,
908 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000909 if (A->getOption().matches(options::OPT_msoft_float))
910 FloatABI = "soft";
911 else if (A->getOption().matches(options::OPT_mhard_float))
912 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000913 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000914 FloatABI = A->getValue();
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000915 if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000916 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000917 FloatABI = "hard";
918 }
919 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000920 }
921
922 // If unspecified, choose the default based on the platform.
923 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000924 // Assume "hard", because it's a default value used by gcc.
925 // When we start to recognize specific target MIPS processors,
926 // we will be able to select the default more correctly.
927 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000928 }
929
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000930 return FloatABI;
931}
932
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000933static void AddTargetFeature(const ArgList &Args,
934 ArgStringList &CmdArgs,
935 OptSpecifier OnOpt,
936 OptSpecifier OffOpt,
937 StringRef FeatureName) {
938 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
939 CmdArgs.push_back("-target-feature");
940 if (A->getOption().matches(OnOpt))
941 CmdArgs.push_back(Args.MakeArgString("+" + FeatureName));
942 else
943 CmdArgs.push_back(Args.MakeArgString("-" + FeatureName));
944 }
945}
946
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000947void Clang::AddMIPSTargetArgs(const ArgList &Args,
948 ArgStringList &CmdArgs) const {
949 const Driver &D = getToolChain().getDriver();
950 StringRef CPUName;
951 StringRef ABIName;
952 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
953
954 CmdArgs.push_back("-target-cpu");
955 CmdArgs.push_back(CPUName.data());
956
957 CmdArgs.push_back("-target-abi");
958 CmdArgs.push_back(ABIName.data());
959
960 StringRef FloatABI = getMipsFloatABI(D, Args);
961
Simon Atanasyan81c423c2013-01-10 12:36:19 +0000962 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
963
964 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000965 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +0000966 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000967 CmdArgs.push_back("-mfloat-abi");
968 CmdArgs.push_back("soft");
969
970 // FIXME: Note, this is a hack. We need to pass the selected float
971 // mode to the MipsTargetInfoBase to define appropriate macros there.
972 // Now it is the only method.
973 CmdArgs.push_back("-target-feature");
974 CmdArgs.push_back("+soft-float");
Simon Atanasyan81c423c2013-01-10 12:36:19 +0000975
976 if (FloatABI == "hard" && IsMips16) {
977 CmdArgs.push_back("-mllvm");
978 CmdArgs.push_back("-mips16-hard-float");
979 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000980 }
981 else if (FloatABI == "single") {
982 // Restrict the use of hardware floating-point
983 // instructions to 32-bit operations.
984 CmdArgs.push_back("-target-feature");
985 CmdArgs.push_back("+single-float");
986 }
987 else {
988 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +0000989 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000990 CmdArgs.push_back("-mfloat-abi");
991 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +0000992 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +0000993
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000994 AddTargetFeature(Args, CmdArgs,
995 options::OPT_mips16, options::OPT_mno_mips16,
996 "mips16");
Simon Atanasyan9c6f1f72012-07-05 19:23:00 +0000997 AddTargetFeature(Args, CmdArgs,
998 options::OPT_mdsp, options::OPT_mno_dsp,
999 "dsp");
1000 AddTargetFeature(Args, CmdArgs,
1001 options::OPT_mdspr2, options::OPT_mno_dspr2,
1002 "dspr2");
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001003
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001004 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1005 if (A->getOption().matches(options::OPT_mxgot)) {
1006 CmdArgs.push_back("-mllvm");
1007 CmdArgs.push_back("-mxgot");
1008 }
1009 }
1010
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001011 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001012 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001013 CmdArgs.push_back("-mllvm");
1014 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1015 A->claim();
1016 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001017}
1018
Hal Finkel8eb59282012-06-11 22:35:19 +00001019/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1020static std::string getPPCTargetCPU(const ArgList &Args) {
1021 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001022 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001023
1024 if (CPUName == "native") {
1025 std::string CPU = llvm::sys::getHostCPUName();
1026 if (!CPU.empty() && CPU != "generic")
1027 return CPU;
1028 else
1029 return "";
1030 }
1031
1032 return llvm::StringSwitch<const char *>(CPUName)
1033 .Case("common", "generic")
1034 .Case("440", "440")
1035 .Case("440fp", "440")
1036 .Case("450", "450")
1037 .Case("601", "601")
1038 .Case("602", "602")
1039 .Case("603", "603")
1040 .Case("603e", "603e")
1041 .Case("603ev", "603ev")
1042 .Case("604", "604")
1043 .Case("604e", "604e")
1044 .Case("620", "620")
1045 .Case("G3", "g3")
1046 .Case("7400", "7400")
1047 .Case("G4", "g4")
1048 .Case("7450", "7450")
1049 .Case("G4+", "g4+")
1050 .Case("750", "750")
1051 .Case("970", "970")
1052 .Case("G5", "g5")
1053 .Case("a2", "a2")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001054 .Case("e500mc", "e500mc")
1055 .Case("e5500", "e5500")
Hal Finkel8eb59282012-06-11 22:35:19 +00001056 .Case("power6", "pwr6")
1057 .Case("power7", "pwr7")
1058 .Case("powerpc", "ppc")
1059 .Case("powerpc64", "ppc64")
1060 .Default("");
1061 }
1062
1063 return "";
1064}
1065
1066void Clang::AddPPCTargetArgs(const ArgList &Args,
1067 ArgStringList &CmdArgs) const {
1068 std::string TargetCPUName = getPPCTargetCPU(Args);
1069
1070 // LLVM may default to generating code for the native CPU,
1071 // but, like gcc, we default to a more generic option for
1072 // each architecture. (except on Darwin)
1073 llvm::Triple Triple = getToolChain().getTriple();
1074 if (TargetCPUName.empty() && !Triple.isOSDarwin()) {
1075 if (Triple.getArch() == llvm::Triple::ppc64)
1076 TargetCPUName = "ppc64";
1077 else
1078 TargetCPUName = "ppc";
1079 }
1080
1081 if (!TargetCPUName.empty()) {
1082 CmdArgs.push_back("-target-cpu");
1083 CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str()));
1084 }
1085}
1086
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001087void Clang::AddSparcTargetArgs(const ArgList &Args,
1088 ArgStringList &CmdArgs) const {
1089 const Driver &D = getToolChain().getDriver();
1090
1091 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001092 CmdArgs.push_back("-target-cpu");
Richard Smithbd55daf2012-11-01 04:30:05 +00001093 CmdArgs.push_back(A->getValue());
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001094 }
1095
1096 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001097 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001098 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1099 options::OPT_mhard_float)) {
1100 if (A->getOption().matches(options::OPT_msoft_float))
1101 FloatABI = "soft";
1102 else if (A->getOption().matches(options::OPT_mhard_float))
1103 FloatABI = "hard";
1104 }
1105
1106 // If unspecified, choose the default based on the platform.
1107 if (FloatABI.empty()) {
1108 switch (getToolChain().getTriple().getOS()) {
1109 default:
1110 // Assume "soft", but warn the user we are guessing.
1111 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001112 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001113 break;
1114 }
1115 }
1116
1117 if (FloatABI == "soft") {
1118 // Floating point operations and argument passing are soft.
1119 //
1120 // FIXME: This changes CPP defines, we need -target-soft-float.
1121 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001122 CmdArgs.push_back("-target-feature");
1123 CmdArgs.push_back("+soft-float");
1124 } else {
1125 assert(FloatABI == "hard" && "Invalid float abi!");
1126 CmdArgs.push_back("-mhard-float");
1127 }
1128}
1129
Chandler Carruth953fb082013-01-13 11:46:33 +00001130static const char *getX86TargetCPU(const ArgList &Args,
1131 const llvm::Triple &Triple) {
1132 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1133 if (StringRef(A->getValue()) != "native")
1134 return A->getValue();
1135
1136 // FIXME: Reject attempts to use -march=native unless the target matches
1137 // the host.
1138 //
1139 // FIXME: We should also incorporate the detected target features for use
1140 // with -native.
1141 std::string CPU = llvm::sys::getHostCPUName();
1142 if (!CPU.empty() && CPU != "generic")
1143 return Args.MakeArgString(CPU);
1144 }
1145
1146 // Select the default CPU if none was given (or detection failed).
1147
1148 if (Triple.getArch() != llvm::Triple::x86_64 &&
1149 Triple.getArch() != llvm::Triple::x86)
1150 return 0; // This routine is only handling x86 targets.
1151
1152 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1153
1154 // FIXME: Need target hooks.
1155 if (Triple.isOSDarwin())
1156 return Is64Bit ? "core2" : "yonah";
1157
1158 // Everything else goes to x86-64 in 64-bit mode.
1159 if (Is64Bit)
1160 return "x86-64";
1161
1162 if (Triple.getOSName().startswith("haiku"))
1163 return "i586";
1164 if (Triple.getOSName().startswith("openbsd"))
1165 return "i486";
1166 if (Triple.getOSName().startswith("bitrig"))
1167 return "i686";
1168 if (Triple.getOSName().startswith("freebsd"))
1169 return "i486";
1170 if (Triple.getOSName().startswith("netbsd"))
1171 return "i486";
1172 // All x86 devices running Android have core2 as their common
1173 // denominator. This makes a better choice than pentium4.
1174 if (Triple.getEnvironment() == llvm::Triple::Android)
1175 return "core2";
1176
1177 // Fallback to p4.
1178 return "pentium4";
1179}
1180
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001181void Clang::AddX86TargetArgs(const ArgList &Args,
1182 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001183 if (!Args.hasFlag(options::OPT_mred_zone,
1184 options::OPT_mno_red_zone,
1185 true) ||
1186 Args.hasArg(options::OPT_mkernel) ||
1187 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001188 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001189
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001190 if (Args.hasFlag(options::OPT_msoft_float,
1191 options::OPT_mno_soft_float,
1192 false))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001193 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001194
Chandler Carruth953fb082013-01-13 11:46:33 +00001195 if (const char *CPUName = getX86TargetCPU(Args, getToolChain().getTriple())) {
Daniel Dunbara7d02312009-12-18 06:30:12 +00001196 CmdArgs.push_back("-target-cpu");
Daniel Dunbare13ada62009-11-14 22:04:54 +00001197 CmdArgs.push_back(CPUName);
1198 }
1199
Eli Friedmanad811f02011-07-02 00:34:19 +00001200 // The required algorithm here is slightly strange: the options are applied
1201 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
1202 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
1203 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
1204 // former correctly, but not the latter; handle directly-overridden
1205 // attributes here.
1206 llvm::StringMap<unsigned> PrevFeature;
1207 std::vector<const char*> Features;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001208 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1209 ie = Args.filtered_end(); it != ie; ++it) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001210 StringRef Name = (*it)->getOption().getName();
Daniel Dunbara442fd52010-06-11 22:00:13 +00001211 (*it)->claim();
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001212
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001213 // Skip over "-m".
Michael J. Spencer929fccd2012-10-22 22:13:48 +00001214 assert(Name.startswith("m") && "Invalid feature name.");
1215 Name = Name.substr(1);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001216
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001217 bool IsNegative = Name.startswith("no-");
1218 if (IsNegative)
1219 Name = Name.substr(3);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001220
Eli Friedmanad811f02011-07-02 00:34:19 +00001221 unsigned& Prev = PrevFeature[Name];
1222 if (Prev)
1223 Features[Prev - 1] = 0;
1224 Prev = Features.size() + 1;
1225 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1226 }
1227 for (unsigned i = 0; i < Features.size(); i++) {
1228 if (Features[i]) {
1229 CmdArgs.push_back("-target-feature");
1230 CmdArgs.push_back(Features[i]);
1231 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001232 }
1233}
1234
Matthew Curtise8f80a12012-12-06 17:49:03 +00001235static inline bool HasPICArg(const ArgList &Args) {
1236 return Args.hasArg(options::OPT_fPIC)
1237 || Args.hasArg(options::OPT_fpic);
1238}
1239
1240static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1241 return Args.getLastArg(options::OPT_G,
1242 options::OPT_G_EQ,
1243 options::OPT_msmall_data_threshold_EQ);
1244}
1245
1246static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1247 std::string value;
1248 if (HasPICArg(Args))
1249 value = "0";
1250 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1251 value = A->getValue();
1252 A->claim();
1253 }
1254 return value;
1255}
1256
Tony Linthicum76329bf2011-12-12 21:14:55 +00001257void Clang::AddHexagonTargetArgs(const ArgList &Args,
1258 ArgStringList &CmdArgs) const {
1259 llvm::Triple Triple = getToolChain().getTriple();
1260
1261 CmdArgs.push_back("-target-cpu");
Matthew Curtisf10a5952012-12-06 14:16:43 +00001262 CmdArgs.push_back(Args.MakeArgString(
1263 "hexagon"
1264 + toolchains::Hexagon_TC::GetTargetCPU(Args)));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001265 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001266 CmdArgs.push_back("-mqdsp6-compat");
1267 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001268
Matthew Curtise8f80a12012-12-06 17:49:03 +00001269 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1270 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001271 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001272 CmdArgs.push_back(Args.MakeArgString(
1273 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001274 }
1275
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001276 if (!Args.hasArg(options::OPT_fno_short_enums))
1277 CmdArgs.push_back("-fshort-enums");
1278 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1279 CmdArgs.push_back ("-mllvm");
1280 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1281 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001282 CmdArgs.push_back ("-mllvm");
1283 CmdArgs.push_back ("-machine-sink-split=0");
1284}
1285
Eric Christopher84fbdb42011-08-19 00:30:14 +00001286static bool
John McCall5fb5df92012-06-20 06:18:46 +00001287shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001288 const llvm::Triple &Triple) {
1289 // We use the zero-cost exception tables for Objective-C if the non-fragile
1290 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1291 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001292 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001293 return true;
1294
Bob Wilson6524dd32011-10-14 05:03:44 +00001295 if (!Triple.isOSDarwin())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001296 return false;
1297
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001298 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001299 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001300 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001301}
1302
Anders Carlssone96ab552011-02-28 02:27:16 +00001303/// addExceptionArgs - Adds exception related arguments to the driver command
1304/// arguments. There's a master flag, -fexceptions and also language specific
1305/// flags to enable/disable C++ and Objective-C exceptions.
1306/// This makes it possible to for example disable C++ exceptions but enable
1307/// Objective-C exceptions.
1308static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1309 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001310 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001311 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001312 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001313 if (KernelOrKext) {
1314 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1315 // arguments now to avoid warnings about unused arguments.
1316 Args.ClaimAllArgs(options::OPT_fexceptions);
1317 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1318 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1319 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1320 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1321 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001322 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001323 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001324
1325 // Exceptions are enabled by default.
1326 bool ExceptionsEnabled = true;
1327
1328 // This keeps track of whether exceptions were explicitly turned on or off.
1329 bool DidHaveExplicitExceptionFlag = false;
1330
Rafael Espindola00a66572009-10-01 13:33:33 +00001331 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1332 options::OPT_fno_exceptions)) {
1333 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001334 ExceptionsEnabled = true;
Eric Christopher84fbdb42011-08-19 00:30:14 +00001335 else
Anders Carlssone96ab552011-02-28 02:27:16 +00001336 ExceptionsEnabled = false;
1337
1338 DidHaveExplicitExceptionFlag = true;
Rafael Espindola00a66572009-10-01 13:33:33 +00001339 }
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001340
Anders Carlssone96ab552011-02-28 02:27:16 +00001341 bool ShouldUseExceptionTables = false;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +00001342
Anders Carlssone96ab552011-02-28 02:27:16 +00001343 // Exception tables and cleanups can be enabled with -fexceptions even if the
1344 // language itself doesn't support exceptions.
1345 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1346 ShouldUseExceptionTables = true;
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001347
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001348 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1349 // is not necessarily sensible, but follows GCC.
1350 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001351 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001352 options::OPT_fno_objc_exceptions,
1353 true)) {
1354 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001355
Eric Christopher84fbdb42011-08-19 00:30:14 +00001356 ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001357 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001358 }
1359
1360 if (types::isCXX(InputType)) {
1361 bool CXXExceptionsEnabled = ExceptionsEnabled;
1362
Eric Christopher84fbdb42011-08-19 00:30:14 +00001363 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1364 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001365 options::OPT_fexceptions,
1366 options::OPT_fno_exceptions)) {
1367 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1368 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001369 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001370 CXXExceptionsEnabled = false;
1371 }
1372
1373 if (CXXExceptionsEnabled) {
1374 CmdArgs.push_back("-fcxx-exceptions");
1375
1376 ShouldUseExceptionTables = true;
1377 }
1378 }
1379
1380 if (ShouldUseExceptionTables)
1381 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001382}
1383
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001384static bool ShouldDisableCFI(const ArgList &Args,
1385 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001386 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001387 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001388 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001389 // we disable them if we think the .s file will be passed to it.
Rafael Espindolac41db922012-03-08 14:39:55 +00001390 Default = Args.hasFlag(options::OPT_integrated_as,
Eric Christopher45f2e712012-12-18 00:31:10 +00001391 options::OPT_no_integrated_as,
1392 TC.IsIntegratedAssemblerDefault());
Rafael Espindolaf934f982011-05-17 16:26:17 +00001393 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001394 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
Eric Christopher45f2e712012-12-18 00:31:10 +00001395 options::OPT_fno_dwarf2_cfi_asm,
1396 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001397}
1398
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001399static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1400 const ToolChain &TC) {
1401 bool IsIADefault = TC.IsIntegratedAssemblerDefault();
1402 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1403 options::OPT_no_integrated_as,
1404 IsIADefault);
1405 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1406 options::OPT_fno_dwarf_directory_asm,
1407 UseIntegratedAs);
1408 return !UseDwarfDirectory;
1409}
1410
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001411/// \brief Check whether the given input tree contains any compilation actions.
1412static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001413 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001414 return true;
1415
1416 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1417 if (ContainsCompileAction(*it))
1418 return true;
1419
1420 return false;
1421}
1422
1423/// \brief Check if -relax-all should be passed to the internal assembler.
1424/// This is done by default when compiling non-assembler source with -O0.
1425static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1426 bool RelaxDefault = true;
1427
1428 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1429 RelaxDefault = A->getOption().matches(options::OPT_O0);
1430
1431 if (RelaxDefault) {
1432 RelaxDefault = false;
1433 for (ActionList::const_iterator it = C.getActions().begin(),
1434 ie = C.getActions().end(); it != ie; ++it) {
1435 if (ContainsCompileAction(*it)) {
1436 RelaxDefault = true;
1437 break;
1438 }
1439 }
1440 }
1441
1442 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1443 RelaxDefault);
1444}
1445
Alexey Samsonovf7a24762013-01-16 11:34:36 +00001446SanitizerArgs::SanitizerArgs(const Driver &D, const ArgList &Args)
Alexey Samsonov29524a92013-01-20 13:12:12 +00001447 : Kind(0), BlacklistFile(""), MsanTrackOrigins(false),
1448 AsanZeroBaseShadow(false) {
Richard Smith52be6192012-11-05 22:04:41 +00001449
Richard Smith52be6192012-11-05 22:04:41 +00001450 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
Alexey Samsonov53f7e122012-11-28 17:34:24 +00001451 unsigned Add, Remove;
1452 if (!parse(D, Args, *I, Add, Remove, true))
Richard Smith52be6192012-11-05 22:04:41 +00001453 continue;
Richard Smith52be6192012-11-05 22:04:41 +00001454 (*I)->claim();
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001455 Kind |= Add;
1456 Kind &= ~Remove;
Richard Smith52be6192012-11-05 22:04:41 +00001457 }
1458
1459 // Only one runtime library can be used at once.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001460 bool NeedsAsan = needsAsanRt();
1461 bool NeedsTsan = needsTsanRt();
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001462 bool NeedsMsan = needsMsanRt();
Richard Smith06d87f12012-12-01 01:02:45 +00001463 if (NeedsAsan && NeedsTsan)
Richard Smith52be6192012-11-05 22:04:41 +00001464 D.Diag(diag::err_drv_argument_not_allowed_with)
Richard Smith06d87f12012-12-01 01:02:45 +00001465 << lastArgumentForKind(D, Args, NeedsAsanRt)
1466 << lastArgumentForKind(D, Args, NeedsTsanRt);
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001467 if (NeedsAsan && NeedsMsan)
1468 D.Diag(diag::err_drv_argument_not_allowed_with)
1469 << lastArgumentForKind(D, Args, NeedsAsanRt)
1470 << lastArgumentForKind(D, Args, NeedsMsanRt);
1471 if (NeedsTsan && NeedsMsan)
1472 D.Diag(diag::err_drv_argument_not_allowed_with)
1473 << lastArgumentForKind(D, Args, NeedsTsanRt)
1474 << lastArgumentForKind(D, Args, NeedsMsanRt);
Alexey Samsonov0e96bec2012-11-29 22:36:21 +00001475
1476 // If -fsanitize contains extra features of ASan, it should also
1477 // explicitly contain -fsanitize=address.
1478 if (NeedsAsan && ((Kind & Address) == 0))
1479 D.Diag(diag::err_drv_argument_only_allowed_with)
1480 << lastArgumentForKind(D, Args, NeedsAsanRt)
1481 << "-fsanitize=address";
Alexey Samsonov9ab73622012-12-03 19:12:58 +00001482
1483 // Parse -f(no-)sanitize-blacklist options.
1484 if (Arg *BLArg = Args.getLastArg(options::OPT_fsanitize_blacklist,
1485 options::OPT_fno_sanitize_blacklist)) {
1486 if (BLArg->getOption().matches(options::OPT_fsanitize_blacklist)) {
1487 std::string BLPath = BLArg->getValue();
1488 bool BLExists = false;
1489 if (!llvm::sys::fs::exists(BLPath, BLExists) && BLExists)
1490 BlacklistFile = BLPath;
1491 else
1492 D.Diag(diag::err_drv_no_such_file) << BLPath;
1493 }
1494 }
Evgeniy Stepanovad8ab3d2012-12-24 08:42:34 +00001495
1496 // Parse -f(no-)sanitize-memory-track-origins options.
Alexey Samsonov29524a92013-01-20 13:12:12 +00001497 if (NeedsMsan)
Evgeniy Stepanovad8ab3d2012-12-24 08:42:34 +00001498 MsanTrackOrigins =
1499 Args.hasFlag(options::OPT_fsanitize_memory_track_origins,
1500 options::OPT_fno_sanitize_memory_track_origins,
1501 /* Default */false);
Alexey Samsonov29524a92013-01-20 13:12:12 +00001502
1503 // Parse -f(no-)sanitize-address-zero-base-shadow options.
1504 if (NeedsAsan)
1505 AsanZeroBaseShadow =
1506 Args.hasFlag(options::OPT_fsanitize_address_zero_base_shadow,
1507 options::OPT_fno_sanitize_address_zero_base_shadow,
1508 /* Default */false);
Richard Smith52be6192012-11-05 22:04:41 +00001509}
1510
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001511/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1512/// This needs to be called before we add the C run-time (malloc, etc).
1513static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00001514 ArgStringList &CmdArgs) {
Logan Chienc6fd8202012-09-02 09:30:11 +00001515 if(TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001516 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovea155f02012-06-04 11:15:05 +00001517 if (!Args.hasArg(options::OPT_pie))
1518 TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001519 }
Daniel Dunbar3ca41d42011-12-07 23:22:17 +00001520
Evgeniy Stepanovcac6aaa2012-09-12 09:09:08 +00001521 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1522 llvm::sys::path::append(LibAsan, "lib", "linux",
1523 (Twine("libclang_rt.asan-") +
1524 TC.getArchName() + "-android.so"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001525 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001526 } else {
1527 if (!Args.hasArg(options::OPT_shared)) {
Alexey Samsonov29524a92013-01-20 13:12:12 +00001528 bool ZeroBaseShadow = Args.hasFlag(
1529 options::OPT_fsanitize_address_zero_base_shadow,
1530 options::OPT_fno_sanitize_address_zero_base_shadow, false);
1531 if (ZeroBaseShadow && !Args.hasArg(options::OPT_pie)) {
1532 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1533 "-fsanitize-address-zero-base-shadow" << "-pie";
1534 }
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001535 // LibAsan is "libclang_rt.asan-<ArchName>.a" in the Linux library
1536 // resource directory.
1537 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1538 llvm::sys::path::append(LibAsan, "lib", "linux",
1539 (Twine("libclang_rt.asan-") +
1540 TC.getArchName() + ".a"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001541 // The ASan runtime needs to come before -lstdc++ (or -lc++, libstdc++.a,
1542 // etc.) so that the linker picks ASan's versions of the global 'operator
1543 // new' and 'operator delete' symbols. We take the extreme (but simple)
Chandler Carruth210c77b2012-12-04 22:54:37 +00001544 // strategy of inserting it at the front of the link command. It also
1545 // needs to be forced to end up in the executable, so wrap it in
1546 // whole-archive.
1547 SmallVector<const char*, 3> PrefixArgs;
1548 PrefixArgs.push_back("-whole-archive");
1549 PrefixArgs.push_back(Args.MakeArgString(LibAsan));
1550 PrefixArgs.push_back("-no-whole-archive");
1551 CmdArgs.insert(CmdArgs.begin(), PrefixArgs.begin(), PrefixArgs.end());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001552 CmdArgs.push_back("-lpthread");
1553 CmdArgs.push_back("-ldl");
1554 CmdArgs.push_back("-export-dynamic");
1555 }
1556 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001557}
1558
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001559/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1560/// This needs to be called before we add the C run-time (malloc, etc).
1561static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1562 ArgStringList &CmdArgs) {
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001563 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001564 if (!Args.hasArg(options::OPT_pie))
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001565 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1566 "-fsanitize=thread" << "-pie";
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001567 // LibTsan is "libclang_rt.tsan-<ArchName>.a" in the Linux library
1568 // resource directory.
1569 SmallString<128> LibTsan(TC.getDriver().ResourceDir);
1570 llvm::sys::path::append(LibTsan, "lib", "linux",
1571 (Twine("libclang_rt.tsan-") +
1572 TC.getArchName() + ".a"));
1573 CmdArgs.push_back(Args.MakeArgString(LibTsan));
1574 CmdArgs.push_back("-lpthread");
1575 CmdArgs.push_back("-ldl");
1576 CmdArgs.push_back("-export-dynamic");
1577 }
1578}
1579
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001580/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1581/// This needs to be called before we add the C run-time (malloc, etc).
1582static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1583 ArgStringList &CmdArgs) {
1584 if (!Args.hasArg(options::OPT_shared)) {
1585 if (!Args.hasArg(options::OPT_pie))
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001586 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1587 "-fsanitize=memory" << "-pie";
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001588 // LibMsan is "libclang_rt.msan-<ArchName>.a" in the Linux library
1589 // resource directory.
1590 SmallString<128> LibMsan(TC.getDriver().ResourceDir);
1591 llvm::sys::path::append(LibMsan, "lib", "linux",
1592 (Twine("libclang_rt.msan-") +
1593 TC.getArchName() + ".a"));
1594 CmdArgs.push_back(Args.MakeArgString(LibMsan));
1595 CmdArgs.push_back("-lpthread");
1596 CmdArgs.push_back("-ldl");
1597 CmdArgs.push_back("-export-dynamic");
1598 }
1599}
1600
Richard Smithe30752c2012-10-09 19:52:38 +00001601/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1602/// (Linux).
1603static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1604 ArgStringList &CmdArgs) {
Richard Smithf75c8b32013-01-18 22:09:26 +00001605 // LibUbsan is "libclang_rt.ubsan-<ArchName>.a" in the Linux library
1606 // resource directory.
1607 SmallString<128> LibUbsan(TC.getDriver().ResourceDir);
1608 llvm::sys::path::append(LibUbsan, "lib", "linux",
1609 (Twine("libclang_rt.ubsan-") +
1610 TC.getArchName() + ".a"));
1611 CmdArgs.push_back(Args.MakeArgString(LibUbsan));
1612 CmdArgs.push_back("-lpthread");
1613 CmdArgs.push_back("-export-dynamic");
Richard Smithe30752c2012-10-09 19:52:38 +00001614}
1615
Rafael Espindola224dd632011-12-14 21:02:23 +00001616static bool shouldUseFramePointer(const ArgList &Args,
1617 const llvm::Triple &Triple) {
1618 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1619 options::OPT_fomit_frame_pointer))
1620 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1621
Rafael Espindola00b29182011-12-14 21:50:24 +00001622 // Don't use a frame pointer on linux x86 and x86_64 if optimizing.
Rafael Espindola224dd632011-12-14 21:02:23 +00001623 if ((Triple.getArch() == llvm::Triple::x86_64 ||
1624 Triple.getArch() == llvm::Triple::x86) &&
1625 Triple.getOS() == llvm::Triple::Linux) {
1626 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1627 if (!A->getOption().matches(options::OPT_O0))
1628 return false;
1629 }
1630
1631 return true;
1632}
1633
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00001634/// If the PWD environment variable is set, add a CC1 option to specify the
1635/// debug compilation directory.
1636static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1637 if (const char *pwd = ::getenv("PWD")) {
1638 // GCC also verifies that stat(pwd) and stat(".") have the same inode
1639 // number. Not doing those because stats are slow, but we could.
1640 if (llvm::sys::path::is_absolute(pwd)) {
1641 std::string CompDir = pwd;
1642 CmdArgs.push_back("-fdebug-compilation-dir");
1643 CmdArgs.push_back(Args.MakeArgString(CompDir));
1644 }
1645 }
1646}
1647
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001648void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00001649 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00001650 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001651 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001652 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00001653 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1654 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00001655 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00001656 ArgStringList CmdArgs;
1657
Daniel Dunbare521a892009-03-31 20:53:55 +00001658 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1659
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00001660 // Invoke ourselves in -cc1 mode.
1661 //
1662 // FIXME: Implement custom jobs for internal actions.
1663 CmdArgs.push_back("-cc1");
1664
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001665 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00001666 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00001667 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001668 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00001669
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001670 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00001671 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00001672
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001673 if (isa<AnalyzeJobAction>(JA)) {
1674 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1675 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00001676 } else if (isa<MigrateJobAction>(JA)) {
1677 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001678 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001679 if (Output.getType() == types::TY_Dependencies)
1680 CmdArgs.push_back("-Eonly");
1681 else
1682 CmdArgs.push_back("-E");
Daniel Dunbarc4343942010-02-03 03:07:56 +00001683 } else if (isa<AssembleJobAction>(JA)) {
1684 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001685
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001686 if (UseRelaxAll(C, Args))
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001687 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001688
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001689 // When using an integrated assembler, translate -Wa, and -Xassembler
1690 // options.
1691 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1692 options::OPT_Xassembler),
1693 ie = Args.filtered_end(); it != ie; ++it) {
1694 const Arg *A = *it;
1695 A->claim();
1696
1697 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001698 StringRef Value = A->getValue(i);
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001699
1700 if (Value == "-force_cpusubtype_ALL") {
1701 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbara78e5892010-10-28 20:36:23 +00001702 } else if (Value == "-L") {
Daniel Dunbar67919b22011-03-28 22:49:28 +00001703 CmdArgs.push_back("-msave-temp-labels");
Joerg Sonnenberger3028e462011-05-19 20:46:39 +00001704 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergerb487d2d2011-05-19 18:42:29 +00001705 CmdArgs.push_back("-mllvm");
1706 CmdArgs.push_back("-fatal-assembler-warnings");
Nick Lewyckyca6b90d2011-06-21 00:14:18 +00001707 } else if (Value == "--noexecstack") {
1708 CmdArgs.push_back("-mnoexecstack");
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001709 } else {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001710 D.Diag(diag::err_drv_unsupported_option_argument)
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001711 << A->getOption().getName() << Value;
1712 }
1713 }
1714 }
Daniel Dunbar7c874332010-11-19 16:23:35 +00001715
1716 // Also ignore explicit -force_cpusubtype_ALL option.
1717 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001718 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00001719 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001720 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001721
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001722 if (JA.getType() == types::TY_Nothing)
1723 CmdArgs.push_back("-fsyntax-only");
1724 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00001725 CmdArgs.push_back("-emit-pch");
1726 else
1727 CmdArgs.push_back("-emit-pth");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001728 } else {
1729 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001730
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001731 if (JA.getType() == types::TY_Nothing) {
1732 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001733 } else if (JA.getType() == types::TY_LLVM_IR ||
1734 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001735 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001736 } else if (JA.getType() == types::TY_LLVM_BC ||
1737 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001738 CmdArgs.push_back("-emit-llvm-bc");
1739 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00001740 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001741 } else if (JA.getType() == types::TY_AST) {
1742 CmdArgs.push_back("-emit-pch");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001743 } else if (JA.getType() == types::TY_RewrittenObjC) {
1744 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001745 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00001746 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1747 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001748 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001749 } else {
1750 assert(JA.getType() == types::TY_PP_Asm &&
1751 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001752 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001753 }
1754
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001755 // The make clang go fast button.
1756 CmdArgs.push_back("-disable-free");
1757
John McCallbb79b5f2010-02-13 03:50:24 +00001758 // Disable the verification pass in -asserts builds.
1759#ifdef NDEBUG
1760 CmdArgs.push_back("-disable-llvm-verifier");
1761#endif
1762
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001763 // Set the main file name, so that debug info works even with
1764 // -save-temps.
1765 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00001766 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001767
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001768 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00001769 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001770 if (Args.hasArg(options::OPT_static))
1771 CmdArgs.push_back("-static-define");
1772
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001773 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00001774 // Enable region store model by default.
1775 CmdArgs.push_back("-analyzer-store=region");
1776
Ted Kremenek7bea9a12009-12-07 22:26:14 +00001777 // Treat blocks as analysis entry points.
1778 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1779
Ted Kremenek49c79792011-03-24 00:28:47 +00001780 CmdArgs.push_back("-analyzer-eagerly-assume");
1781
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001782 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001783 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001784 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00001785
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001786 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1787 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00001788
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001789 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00001790 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00001791
1792 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00001793
1794 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00001795 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
1796 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
1797 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
1798 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
1799 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
1800 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001801 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001802
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001803 // Set the output format. The default is plist, for (lame) historical
1804 // reasons.
1805 CmdArgs.push_back("-analyzer-output");
1806 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00001807 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001808 else
1809 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001810
Ted Kremenekfe449a22010-03-22 22:32:05 +00001811 // Disable the presentation of standard compiler warnings when
1812 // using --analyze. We only want to show static analyzer diagnostics
1813 // or frontend errors.
1814 CmdArgs.push_back("-w");
1815
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001816 // Add -Xanalyzer arguments when running as analyzer.
1817 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00001818 }
1819
Daniel Dunbar4eadb602009-09-10 01:21:12 +00001820 CheckCodeGenerationOptions(D, Args);
1821
Chandler Carruth76a943b2012-11-19 03:52:03 +00001822 // For the PIC and PIE flag options, this logic is different from the legacy
1823 // logic in very old versions of GCC, as that logic was just a bug no one had
1824 // ever fixed. This logic is both more rational and consistent with GCC's new
1825 // logic now that the bugs are fixed. The last argument relating to either
1826 // PIC or PIE wins, and no other argument is used. If the last argument is
1827 // any flavor of the '-fno-...' arguments, both PIC and PIE are disabled. Any
1828 // PIE option implicitly enables PIC at the same level.
1829 bool PIE = false;
1830 bool PIC = getToolChain().isPICDefault();
1831 bool IsPICLevelTwo = PIC;
1832 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1833 options::OPT_fpic, options::OPT_fno_pic,
1834 options::OPT_fPIE, options::OPT_fno_PIE,
1835 options::OPT_fpie, options::OPT_fno_pie)) {
1836 Option O = A->getOption();
1837 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1838 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1839 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1840 PIC = PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1841 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
1842 O.matches(options::OPT_fPIC);
1843 } else {
1844 PIE = PIC = false;
1845 }
Benjamin Kramer76db2902012-11-13 15:32:35 +00001846 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00001847 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
1848 // is forced, then neither PIC nor PIE flags will have no effect.
1849 if (getToolChain().isPICDefaultForced()) {
1850 PIE = false;
1851 PIC = getToolChain().isPICDefault();
1852 IsPICLevelTwo = PIC;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001853 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00001854
1855 // Inroduce a Darwin-specific hack. If the default is PIC but the flags
1856 // specified while enabling PIC enabled level 1 PIC, just force it back to
1857 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
1858 // informal testing).
1859 if (PIC && getToolChain().getTriple().isOSDarwin())
1860 IsPICLevelTwo |= getToolChain().isPICDefault();
1861
Chandler Carruthc0c04552012-04-08 16:40:35 +00001862 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
1863 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00001864 llvm::Triple Triple(TripleStr);
1865 if ((Args.hasArg(options::OPT_mkernel) ||
1866 Args.hasArg(options::OPT_fapple_kext)) &&
1867 (Triple.getOS() != llvm::Triple::IOS ||
1868 Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00001869 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001870 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00001871 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001872
Chandler Carruth76a943b2012-11-19 03:52:03 +00001873 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1874 // This is a very special mode. It trumps the other modes, almost no one
1875 // uses it, and it isn't even valid on any OS but Darwin.
1876 if (!getToolChain().getTriple().isOSDarwin())
1877 D.Diag(diag::err_drv_unsupported_opt_for_target)
1878 << A->getSpelling() << getToolChain().getTriple().str();
1879
1880 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
1881
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001882 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00001883 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00001884
Chandler Carruth76a943b2012-11-19 03:52:03 +00001885 // Only a forced PIC mode can cause the actual compile to have PIC defines
1886 // etc., no flags are sufficient. This behavior was selected to closely
1887 // match that of llvm-gcc and Apple GCC before that.
1888 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
1889 CmdArgs.push_back("-pic-level");
1890 CmdArgs.push_back("2");
1891 }
1892 } else {
1893 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
1894 // handled in Clang's IRGen by the -pie-level flag.
1895 CmdArgs.push_back("-mrelocation-model");
1896 CmdArgs.push_back(PIC ? "pic" : "static");
1897
1898 if (PIC) {
1899 CmdArgs.push_back("-pic-level");
1900 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
1901 if (PIE) {
1902 CmdArgs.push_back("-pie-level");
1903 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
1904 }
1905 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00001906 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00001907
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00001908 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1909 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00001910 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00001911
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001912 // LLVM Code Generator Options.
1913
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001914 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1915 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00001916 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001917 }
1918
Roman Divacky65b88cd2011-03-01 17:40:53 +00001919 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1920 CmdArgs.push_back("-mrtd");
1921
Rafael Espindola224dd632011-12-14 21:02:23 +00001922 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001923 CmdArgs.push_back("-mdisable-fp-elim");
1924 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1925 options::OPT_fno_zero_initialized_in_bss))
1926 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Daniel Dunbar7aa71f92011-02-04 02:20:39 +00001927 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1928 options::OPT_fno_strict_aliasing,
1929 getToolChain().IsStrictAliasingDefault()))
Dan Gohman10169b92010-10-14 22:36:56 +00001930 CmdArgs.push_back("-relaxed-aliasing");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00001931 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
1932 false))
1933 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00001934 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
1935 options::OPT_fno_optimize_sibling_calls))
1936 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00001937
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001938 // Handle various floating point optimization flags, mapping them to the
1939 // appropriate LLVM code generation flags. The pattern for all of these is to
1940 // default off the codegen optimizations, and if any flag enables them and no
1941 // flag disables them after the flag enabling them, enable the codegen
1942 // optimization. This is complicated by several "umbrella" flags.
1943 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001944 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001945 options::OPT_ffinite_math_only,
1946 options::OPT_fno_finite_math_only,
1947 options::OPT_fhonor_infinities,
1948 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001949 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1950 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001951 A->getOption().getID() != options::OPT_fhonor_infinities)
1952 CmdArgs.push_back("-menable-no-infs");
1953 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001954 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001955 options::OPT_ffinite_math_only,
1956 options::OPT_fno_finite_math_only,
1957 options::OPT_fhonor_nans,
1958 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001959 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1960 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001961 A->getOption().getID() != options::OPT_fhonor_nans)
1962 CmdArgs.push_back("-menable-no-nans");
1963
Benjamin Kramerc242ef22012-05-02 14:55:48 +00001964 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
1965 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001966 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001967 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001968 options::OPT_fmath_errno,
Chandler Carruth3634c662012-04-26 02:10:51 +00001969 options::OPT_fno_math_errno))
1970 MathErrno = A->getOption().getID() == options::OPT_fmath_errno;
1971 if (MathErrno)
1972 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001973
1974 // There are several flags which require disabling very specific
1975 // optimizations. Any of these being disabled forces us to turn off the
1976 // entire set of LLVM optimizations, so collect them through all the flag
1977 // madness.
1978 bool AssociativeMath = false;
1979 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001980 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001981 options::OPT_funsafe_math_optimizations,
1982 options::OPT_fno_unsafe_math_optimizations,
1983 options::OPT_fassociative_math,
1984 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001985 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1986 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001987 A->getOption().getID() != options::OPT_fno_associative_math)
1988 AssociativeMath = true;
1989 bool ReciprocalMath = false;
1990 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001991 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001992 options::OPT_funsafe_math_optimizations,
1993 options::OPT_fno_unsafe_math_optimizations,
1994 options::OPT_freciprocal_math,
1995 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001996 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1997 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001998 A->getOption().getID() != options::OPT_fno_reciprocal_math)
1999 ReciprocalMath = true;
2000 bool SignedZeros = true;
2001 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002002 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002003 options::OPT_funsafe_math_optimizations,
2004 options::OPT_fno_unsafe_math_optimizations,
2005 options::OPT_fsigned_zeros,
2006 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002007 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2008 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002009 A->getOption().getID() != options::OPT_fsigned_zeros)
2010 SignedZeros = false;
2011 bool TrappingMath = true;
2012 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002013 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002014 options::OPT_funsafe_math_optimizations,
2015 options::OPT_fno_unsafe_math_optimizations,
2016 options::OPT_ftrapping_math,
2017 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002018 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2019 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002020 A->getOption().getID() != options::OPT_ftrapping_math)
2021 TrappingMath = false;
2022 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2023 !TrappingMath)
2024 CmdArgs.push_back("-menable-unsafe-fp-math");
2025
Lang Hamesaa53b932012-07-06 00:59:19 +00002026
2027 // Validate and pass through -fp-contract option.
2028 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002029 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002030 options::OPT_ffp_contract)) {
2031 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002032 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002033 if (Val == "fast" || Val == "on" || Val == "off") {
2034 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2035 } else {
2036 D.Diag(diag::err_drv_unsupported_option_argument)
2037 << A->getOption().getName() << Val;
2038 }
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002039 } else if (A->getOption().getID() == options::OPT_ffast_math) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002040 // If fast-math is set then set the fp-contract mode to fast.
2041 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2042 }
2043 }
2044
Bob Wilson6a039162012-07-19 03:52:53 +00002045 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2046 // and if we find them, tell the frontend to provide the appropriate
2047 // preprocessor macros. This is distinct from enabling any optimizations as
2048 // these options induce language changes which must survive serialization
2049 // and deserialization, etc.
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002050 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math))
2051 if (A->getOption().matches(options::OPT_ffast_math))
2052 CmdArgs.push_back("-ffast-math");
2053 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2054 if (A->getOption().matches(options::OPT_ffinite_math_only))
2055 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002056
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002057 // Decide whether to use verbose asm. Verbose assembly is the default on
2058 // toolchains which have the integrated assembler on by default.
2059 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2060 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002061 IsVerboseAsmDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002062 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002063 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002064
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002065 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2066 CmdArgs.push_back("-mdebug-pass");
2067 CmdArgs.push_back("Structure");
2068 }
2069 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2070 CmdArgs.push_back("-mdebug-pass");
2071 CmdArgs.push_back("Arguments");
2072 }
2073
John McCall8517abc2010-02-19 02:45:38 +00002074 // Enable -mconstructor-aliases except on darwin, where we have to
2075 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002076 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002077 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002078
John McCall7ef5cb32011-03-18 02:56:14 +00002079 // Darwin's kernel doesn't support guard variables; just die if we
2080 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002081 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002082 CmdArgs.push_back("-fforbid-guard-variables");
2083
Douglas Gregordbe39272011-02-01 15:15:22 +00002084 if (Args.hasArg(options::OPT_mms_bitfields)) {
2085 CmdArgs.push_back("-mms-bitfields");
2086 }
John McCall8517abc2010-02-19 02:45:38 +00002087
Daniel Dunbar306945d2009-09-16 06:17:29 +00002088 // This is a coarse approximation of what llvm-gcc actually does, both
2089 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2090 // complicated ways.
2091 bool AsynchronousUnwindTables =
2092 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2093 options::OPT_fno_asynchronous_unwind_tables,
2094 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002095 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002096 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2097 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002098 CmdArgs.push_back("-munwind-tables");
2099
Chandler Carruth05fb5852012-11-21 23:40:23 +00002100 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002101
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002102 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2103 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002104 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002105 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002106
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002107 // FIXME: Handle -mtune=.
2108 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002109
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002110 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002111 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002112 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002113 }
2114
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002115 // Add target specific cpu and features flags.
2116 switch(getToolChain().getTriple().getArch()) {
2117 default:
2118 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002119
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002120 case llvm::Triple::arm:
2121 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002122 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002123 break;
2124
Eric Christopher0b26a612010-03-02 02:41:08 +00002125 case llvm::Triple::mips:
2126 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002127 case llvm::Triple::mips64:
2128 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002129 AddMIPSTargetArgs(Args, CmdArgs);
2130 break;
2131
Hal Finkel8eb59282012-06-11 22:35:19 +00002132 case llvm::Triple::ppc:
2133 case llvm::Triple::ppc64:
2134 AddPPCTargetArgs(Args, CmdArgs);
2135 break;
2136
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002137 case llvm::Triple::sparc:
2138 AddSparcTargetArgs(Args, CmdArgs);
2139 break;
2140
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002141 case llvm::Triple::x86:
2142 case llvm::Triple::x86_64:
2143 AddX86TargetArgs(Args, CmdArgs);
2144 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002145
2146 case llvm::Triple::hexagon:
2147 AddHexagonTargetArgs(Args, CmdArgs);
2148 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002149 }
2150
Tony Linthicum76329bf2011-12-12 21:14:55 +00002151
2152
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002153 // Pass the linker version in use.
2154 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2155 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002156 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002157 }
2158
Nick Lewycky75033772011-02-02 06:43:03 +00002159 // -mno-omit-leaf-frame-pointer is the default on Darwin.
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002160 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
Nick Lewycky75033772011-02-02 06:43:03 +00002161 options::OPT_mno_omit_leaf_frame_pointer,
Bob Wilson6524dd32011-10-14 05:03:44 +00002162 !getToolChain().getTriple().isOSDarwin()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002163 CmdArgs.push_back("-momit-leaf-frame-pointer");
2164
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002165 // Explicitly error on some things we know we don't support and can't just
2166 // ignore.
2167 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002168 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2169 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002170 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002171 getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002172 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002173 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2174 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002175 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002176 << Unsupported->getOption().getName();
2177 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002178 }
2179
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002180 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002181 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002182 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002183 CmdArgs.push_back("-header-include-file");
2184 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2185 D.CCPrintHeadersFilename : "-");
2186 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002187 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002188 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002189
Chad Rosierbe10f982011-08-02 17:58:04 +00002190 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002191 CmdArgs.push_back("-diagnostic-log-file");
2192 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2193 D.CCLogDiagnosticsFilename : "-");
2194 }
2195
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002196 // Use the last option from "-g" group. "-gline-tables-only" is
2197 // preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002198 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002199 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2200 if (A->getOption().matches(options::OPT_gline_tables_only)) {
2201 CmdArgs.push_back("-gline-tables-only");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002202 } else if (!A->getOption().matches(options::OPT_g0) &&
2203 !A->getOption().matches(options::OPT_ggdb0)) {
Chad Rosier8fe3b112011-11-07 19:52:29 +00002204 CmdArgs.push_back("-g");
Chad Rosierc2bf3382011-11-04 19:28:44 +00002205 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002206 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002207
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002208 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2209 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002210 if (Args.hasArg(options::OPT_gcolumn_info))
2211 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002212
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002213 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2214 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2215
Chris Lattner3c77a352010-06-22 00:03:40 +00002216 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2217
Nick Lewycky207bce32011-04-21 23:44:07 +00002218 if (Args.hasArg(options::OPT_ftest_coverage) ||
2219 Args.hasArg(options::OPT_coverage))
2220 CmdArgs.push_back("-femit-coverage-notes");
2221 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2222 Args.hasArg(options::OPT_coverage))
2223 CmdArgs.push_back("-femit-coverage-data");
2224
Nick Lewycky480cb992011-05-04 20:46:58 +00002225 if (C.getArgs().hasArg(options::OPT_c) ||
2226 C.getArgs().hasArg(options::OPT_S)) {
2227 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002228 CmdArgs.push_back("-coverage-file");
Bill Wendling8c0b4bc2012-08-30 00:43:41 +00002229 SmallString<128> absFilename(Output.getFilename());
2230 llvm::sys::fs::make_absolute(absFilename);
2231 CmdArgs.push_back(Args.MakeArgString(absFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002232 }
2233 }
2234
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002235 // Pass options for controlling the default header search paths.
2236 if (Args.hasArg(options::OPT_nostdinc)) {
2237 CmdArgs.push_back("-nostdsysteminc");
2238 CmdArgs.push_back("-nobuiltininc");
2239 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002240 if (Args.hasArg(options::OPT_nostdlibinc))
2241 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002242 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2243 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2244 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002245
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002246 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002247 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002248 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002249
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002250 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2251
Ted Kremenekf7639e12012-03-06 20:06:33 +00002252 bool ARCMTEnabled = false;
John McCalld70fb982011-06-15 23:25:17 +00002253 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002254 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002255 options::OPT_ccc_arcmt_modify,
2256 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002257 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002258 switch (A->getOption().getID()) {
2259 default:
2260 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002261 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002262 CmdArgs.push_back("-arcmt-check");
2263 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002264 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002265 CmdArgs.push_back("-arcmt-modify");
2266 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002267 case options::OPT_ccc_arcmt_migrate:
2268 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002269 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002270 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002271
2272 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2273 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002274 break;
John McCalld70fb982011-06-15 23:25:17 +00002275 }
2276 }
2277 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002278
Ted Kremenekf7639e12012-03-06 20:06:33 +00002279 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2280 if (ARCMTEnabled) {
2281 D.Diag(diag::err_drv_argument_not_allowed_with)
2282 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2283 }
2284 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002285 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002286
2287 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2288 options::OPT_objcmt_migrate_subscripting)) {
2289 // None specified, means enable them all.
2290 CmdArgs.push_back("-objcmt-migrate-literals");
2291 CmdArgs.push_back("-objcmt-migrate-subscripting");
2292 } else {
2293 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2294 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2295 }
2296 }
2297
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002298 // Add preprocessing options like -I, -D, etc. if we are using the
2299 // preprocessor.
2300 //
2301 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002302 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Peter Collingbourne9b515cb2011-11-06 00:40:05 +00002303 AddPreprocessingOptions(C, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002304
Rafael Espindolaa7431922011-07-21 23:40:37 +00002305 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2306 // that "The compiler can only warn and ignore the option if not recognized".
2307 // When building with ccache, it will pass -D options to clang even on
2308 // preprocessed inputs and configure concludes that -fPIC is not supported.
2309 Args.ClaimAllArgs(options::OPT_D);
2310
Daniel Dunbar58f78332009-09-17 06:53:36 +00002311 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar13864952009-03-24 20:17:30 +00002312 // others.
2313 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00002314 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar13864952009-03-24 20:17:30 +00002315 CmdArgs.push_back("-O3");
Daniel Dunbar9296f632010-05-27 06:51:08 +00002316 else if (A->getOption().matches(options::OPT_O) &&
Richard Smithbd55daf2012-11-01 04:30:05 +00002317 A->getValue()[0] == '\0')
Daniel Dunbar58f78332009-09-17 06:53:36 +00002318 CmdArgs.push_back("-O2");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002319 else
Daniel Dunbar7ef5ed62009-03-18 23:39:35 +00002320 A->render(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002321 }
2322
Chad Rosier86b82082012-12-12 20:06:31 +00002323 // Don't warn about unused -flto. This can happen when we're preprocessing or
2324 // precompiling.
2325 Args.ClaimAllArgs(options::OPT_flto);
2326
Daniel Dunbar945577c2009-10-29 02:24:45 +00002327 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002328 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2329 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002330 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002331 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002332
2333 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2334 // (-ansi is equivalent to -std=c89).
2335 //
2336 // If a std is supplied, only add -trigraphs if it follows the
2337 // option.
2338 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2339 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002340 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002341 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002342 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002343 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002344 else
2345 Std->render(Args, CmdArgs);
2346
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002347 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2348 options::OPT_trigraphs))
2349 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002350 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002351 } else {
2352 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002353 //
2354 // FIXME: Clang doesn't correctly handle -std= when the input language
2355 // doesn't match. For the time being just ignore this for C++ inputs;
2356 // eventually we want to do all the standard defaulting here instead of
2357 // splitting it between the driver and clang -cc1.
2358 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002359 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2360 "-std=", /*Joined=*/true);
2361 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2362 CmdArgs.push_back("-std=c++11");
2363
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002364 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002365 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002366
Chandler Carruthb009b142011-04-23 06:30:43 +00002367 // Map the bizarre '-Wwrite-strings' flag to a more sensible
2368 // '-fconst-strings'; this better indicates its actual behavior.
2369 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
2370 false)) {
2371 // For perfect compatibility with GCC, we do this even in the presence of
2372 // '-w'. This flag names something other than a warning for GCC.
2373 CmdArgs.push_back("-fconst-strings");
2374 }
2375
Chandler Carruth61fbf622011-04-23 09:27:53 +00002376 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002377 // during C++ compilation, which it is by default. GCC keeps this define even
2378 // in the presence of '-w', match this behavior bug-for-bug.
2379 if (types::isCXX(InputType) &&
2380 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2381 true)) {
2382 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002383 }
2384
Chandler Carruthe0391482010-05-22 02:21:53 +00002385 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2386 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2387 if (Asm->getOption().matches(options::OPT_fasm))
2388 CmdArgs.push_back("-fgnu-keywords");
2389 else
2390 CmdArgs.push_back("-fno-gnu-keywords");
2391 }
2392
Rafael Espindola4cfa7972011-05-02 17:43:32 +00002393 if (ShouldDisableCFI(Args, getToolChain()))
2394 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00002395
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002396 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2397 CmdArgs.push_back("-fno-dwarf-directory-asm");
2398
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002399 // Add in -fdebug-compilation-dir if necessary.
2400 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00002401
Richard Smith9a568822011-11-21 19:36:32 +00002402 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2403 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002404 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002405 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002406 }
2407
Richard Smith9a568822011-11-21 19:36:32 +00002408 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2409 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002410 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00002411 }
2412
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00002413 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2414 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002415 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002416 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002417 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2418 } else
2419 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00002420 }
2421
Nuno Lopes3d6311d2012-05-08 22:10:46 +00002422
Michael J. Spencer929fccd2012-10-22 22:13:48 +00002423 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002424 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00002425
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002426 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2427 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00002428 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002429 }
David Chisnall5778fce2009-08-31 16:41:57 +00002430
Chris Lattnere23003d2010-01-09 21:54:33 +00002431 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2432 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00002433 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00002434 }
2435
Chris Lattnerb35583d2010-04-07 20:49:23 +00002436 CmdArgs.push_back("-ferror-limit");
2437 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00002438 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00002439 else
2440 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00002441
Chandler Carrutha77a7272010-05-06 04:55:18 +00002442 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2443 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002444 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002445 }
2446
2447 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2448 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002449 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002450 }
2451
Richard Smithf6f003a2011-12-16 19:06:07 +00002452 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2453 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002454 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00002455 }
2456
Daniel Dunbar2c978472009-11-04 06:24:47 +00002457 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00002458 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00002459 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002460 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00002461 } else {
2462 // If -fmessage-length=N was not specified, determine whether this is a
2463 // terminal and, if so, implicitly define -fmessage-length appropriately.
2464 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002465 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00002466 }
2467
Daniel Dunbare357d562009-12-03 18:42:11 +00002468 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
2469 CmdArgs.push_back("-fvisibility");
Richard Smithbd55daf2012-11-01 04:30:05 +00002470 CmdArgs.push_back(A->getValue());
Daniel Dunbare357d562009-12-03 18:42:11 +00002471 }
2472
Douglas Gregor08329632010-06-15 17:05:35 +00002473 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002474
Hans Wennborgf60f6af2012-06-28 08:01:44 +00002475 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2476
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002477 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002478 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2479 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002480 CmdArgs.push_back("-ffreestanding");
2481
Daniel Dunbare357d562009-12-03 18:42:11 +00002482 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002483 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002484 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patel91bbb552010-09-30 19:05:55 +00002485 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Devang Patel384dfa42011-11-04 20:05:58 +00002486 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
Eric Christopher86050822011-10-25 07:13:06 +00002487 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Anton Yartsev9b6b2e52011-12-23 20:23:19 +00002488 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00002489 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2490 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00002491
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002492 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00002493 Sanitize.addArgs(Args, CmdArgs);
2494
Will Dietz3676d562012-12-30 20:53:28 +00002495 if (!Args.hasFlag(options::OPT_fsanitize_recover,
2496 options::OPT_fno_sanitize_recover,
2497 true))
2498 CmdArgs.push_back("-fno-sanitize-recover");
2499
Chad Rosier864dfe12012-03-13 23:45:51 +00002500 // Report and error for -faltivec on anything other then PowerPC.
2501 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
2502 if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc ||
2503 getToolChain().getTriple().getArch() == llvm::Triple::ppc64))
2504 D.Diag(diag::err_drv_argument_only_allowed_with)
2505 << A->getAsString(Args) << "ppc/ppc64";
2506
Daniel Dunbar733b0f82011-03-01 18:49:30 +00002507 if (getToolChain().SupportsProfiling())
2508 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00002509
2510 // -flax-vector-conversions is default.
2511 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2512 options::OPT_fno_lax_vector_conversions))
2513 CmdArgs.push_back("-fno-lax-vector-conversions");
2514
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002515 if (Args.getLastArg(options::OPT_fapple_kext))
2516 CmdArgs.push_back("-fapple-kext");
2517
David Blaikie690f21e2012-06-14 18:55:27 +00002518 if (Args.hasFlag(options::OPT_frewrite_includes,
2519 options::OPT_fno_rewrite_includes, false))
2520 CmdArgs.push_back("-frewrite-includes");
2521
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00002522 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00002523 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00002524 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002525 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2526 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00002527
2528 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2529 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00002530 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00002531 }
2532
Bob Wilson14adb362012-02-03 06:27:22 +00002533 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00002534
Chandler Carruth6e501032011-03-27 00:04:55 +00002535 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2536 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2537 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2538 options::OPT_fno_wrapv)) {
2539 if (A->getOption().matches(options::OPT_fwrapv))
2540 CmdArgs.push_back("-fwrapv");
2541 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2542 options::OPT_fno_strict_overflow)) {
2543 if (A->getOption().matches(options::OPT_fno_strict_overflow))
2544 CmdArgs.push_back("-fwrapv");
2545 }
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002546 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf387dbd2010-08-07 23:08:14 +00002547 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002548
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00002549 Args.AddLastArg(CmdArgs, options::OPT_pthread);
2550
Mahesha S6a682be42012-10-27 07:47:56 +00002551
Daniel Dunbar4930e332009-11-17 08:07:36 +00002552 // -stack-protector=0 is default.
2553 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002554 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2555 options::OPT_fstack_protector_all,
2556 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002557 if (A->getOption().matches(options::OPT_fstack_protector))
2558 StackProtectorLevel = 1;
2559 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2560 StackProtectorLevel = 2;
Nico Weberdd473632011-08-23 07:38:27 +00002561 } else {
2562 StackProtectorLevel =
2563 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2564 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002565 if (StackProtectorLevel) {
2566 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002567 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002568 }
Chad Rosierdb3da832012-08-21 16:16:06 +00002569
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002570 // --param ssp-buffer-size=
2571 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
2572 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002573 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002574 if (Str.startswith("ssp-buffer-size=")) {
2575 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00002576 CmdArgs.push_back("-stack-protector-buffer-size");
2577 // FIXME: Verify the argument is a valid integer.
2578 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00002579 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002580 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00002581 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002582 }
2583
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00002584 // Translate -mstackrealign
2585 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2586 false)) {
2587 CmdArgs.push_back("-backend-option");
2588 CmdArgs.push_back("-force-align-stack");
2589 }
2590 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2591 false)) {
2592 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2593 }
2594
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00002595 if (Args.hasArg(options::OPT_mstack_alignment)) {
2596 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2597 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00002598 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00002599 // -mkernel implies -mstrict-align; don't add the redundant option.
2600 if (Args.hasArg(options::OPT_mstrict_align) && !KernelOrKext) {
Chad Rosierd87e4f72012-11-09 18:27:01 +00002601 CmdArgs.push_back("-backend-option");
2602 CmdArgs.push_back("-arm-strict-align");
Chad Rosier60027022012-11-09 17:29:19 +00002603 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002604
Daniel Dunbard18049a2009-04-07 21:16:11 +00002605 // Forward -f options with positive and negative forms; we translate
2606 // these by hand.
2607
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002608 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00002609 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002610 CmdArgs.push_back("-fapple-kext");
2611 if (!Args.hasArg(options::OPT_fbuiltin))
2612 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00002613 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002614 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002615 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002616 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00002617 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00002618
Nuno Lopes13c88c72009-12-16 16:59:22 +00002619 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2620 options::OPT_fno_assume_sane_operator_new))
2621 CmdArgs.push_back("-fno-assume-sane-operator-new");
2622
Daniel Dunbar4930e332009-11-17 08:07:36 +00002623 // -fblocks=0 is default.
2624 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00002625 getToolChain().IsBlocksDefault()) ||
2626 (Args.hasArg(options::OPT_fgnu_runtime) &&
2627 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
2628 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002629 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00002630
2631 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
2632 !getToolChain().hasBlocksRuntime())
2633 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00002634 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00002635
Douglas Gregor226173a2012-01-18 15:19:58 +00002636 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
2637 // users must also pass -fcxx-modules. The latter flag will disappear once the
2638 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00002639 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00002640 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
2641 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2642 options::OPT_fno_cxx_modules,
2643 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00002644 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00002645 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00002646 HaveModules = true;
2647 }
2648 }
2649
2650 // -fmodules-autolink (on by default when modules is enabled) automatically
2651 // links against libraries for imported modules.
2652 if (HaveModules &&
2653 Args.hasFlag(options::OPT_fmodules_autolink,
2654 options::OPT_fno_modules_autolink,
2655 true)) {
2656 CmdArgs.push_back("-fmodules-autolink");
Douglas Gregor226173a2012-01-18 15:19:58 +00002657 }
Douglas Gregor787869b2012-01-03 17:13:05 +00002658
John McCalldfea9982010-04-09 19:12:06 +00002659 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00002660 if (Args.hasFlag(options::OPT_fno_access_control,
2661 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00002662 false))
John McCall3155f572010-04-09 19:03:51 +00002663 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00002664
Anders Carlssond470fef2010-11-21 00:09:52 +00002665 // -felide-constructors is the default.
2666 if (Args.hasFlag(options::OPT_fno_elide_constructors,
2667 options::OPT_felide_constructors,
2668 false))
2669 CmdArgs.push_back("-fno-elide-constructors");
2670
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002671 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002672 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00002673 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00002674 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00002675
Richard Smith52be6192012-11-05 22:04:41 +00002676 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002677 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00002678 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00002679 Args.getLastArg(options::OPT_mkernel,
2680 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00002681 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00002682 D.Diag(diag::err_drv_argument_not_allowed_with)
2683 << "-fsanitize=vptr" << NoRttiArg;
2684 }
2685 }
2686
Tony Linthicum76329bf2011-12-12 21:14:55 +00002687 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002688 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00002689 options::OPT_fno_short_enums,
2690 getToolChain().getTriple().getArch() ==
2691 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002692 CmdArgs.push_back("-fshort-enums");
2693
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002694 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002695 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002696 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00002697 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00002698
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002699 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002700 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002701 options::OPT_fno_threadsafe_statics))
2702 CmdArgs.push_back("-fno-threadsafe-statics");
2703
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002704 // -fuse-cxa-atexit is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002705 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
2706 options::OPT_fno_use_cxa_atexit,
2707 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
Tony Linthicum76329bf2011-12-12 21:14:55 +00002708 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Chad Rosier4fab82c2012-03-26 22:04:46 +00002709 getToolChain().getTriple().getArch() != llvm::Triple::hexagon) ||
2710 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002711 CmdArgs.push_back("-fno-use-cxa-atexit");
2712
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002713 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002714 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002715 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2716 CmdArgs.push_back("-fms-extensions");
2717
Chad Rosiered943242012-07-20 21:20:33 +00002718 // -fms-inline-asm.
Chad Rosierd3957e52012-07-20 23:12:26 +00002719 if (Args.hasArg(options::OPT_fenable_experimental_ms_inline_asm))
2720 CmdArgs.push_back("-fenable-experimental-ms-inline-asm");
Chad Rosiered943242012-07-20 21:20:33 +00002721
Francois Pichet1b4f1632011-09-17 04:32:15 +00002722 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00002723 if (Args.hasFlag(options::OPT_fms_compatibility,
2724 options::OPT_fno_ms_compatibility,
2725 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
2726 Args.hasFlag(options::OPT_fms_extensions,
2727 options::OPT_fno_ms_extensions,
2728 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00002729 CmdArgs.push_back("-fms-compatibility");
2730
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002731 // -fmsc-version=1300 is default.
2732 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2733 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
2734 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002735 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002736 if (msc_ver.empty())
2737 CmdArgs.push_back("-fmsc-version=1300");
2738 else
2739 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
2740 }
2741
2742
Dawn Perchik68bb1b42010-09-02 23:59:25 +00002743 // -fborland-extensions=0 is default.
2744 if (Args.hasFlag(options::OPT_fborland_extensions,
2745 options::OPT_fno_borland_extensions, false))
2746 CmdArgs.push_back("-fborland-extensions");
2747
Francois Pichet02744872011-09-01 16:38:08 +00002748 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
2749 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00002750 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
2751 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00002752 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00002753 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00002754
Chandler Carruthe03aa552010-04-17 20:17:31 +00002755 // -fgnu-keywords default varies depending on language; only pass if
2756 // specified.
2757 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00002758 options::OPT_fno_gnu_keywords))
2759 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00002760
Rafael Espindola922a6242011-06-02 17:30:53 +00002761 if (Args.hasFlag(options::OPT_fgnu89_inline,
2762 options::OPT_fno_gnu89_inline,
2763 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00002764 CmdArgs.push_back("-fgnu89-inline");
2765
Chad Rosier9c76d242012-03-15 22:31:42 +00002766 if (Args.hasArg(options::OPT_fno_inline))
2767 CmdArgs.push_back("-fno-inline");
2768
Chad Rosier64d6be92012-03-06 21:17:19 +00002769 if (Args.hasArg(options::OPT_fno_inline_functions))
2770 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00002771
John McCall5fb5df92012-06-20 06:18:46 +00002772 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00002773
John McCall5fb5df92012-06-20 06:18:46 +00002774 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
2775 // legacy is the default.
2776 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00002777 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2778 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00002779 objcRuntime.isLegacyDispatchDefaultForArch(
2780 getToolChain().getTriple().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00002781 if (getToolChain().UseObjCMixedDispatch())
2782 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
2783 else
2784 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
2785 }
2786 }
2787
Nico Weber97bd94b2012-03-09 21:19:44 +00002788 // -fobjc-default-synthesize-properties=1 is default. This only has an effect
2789 // if the nonfragile objc abi is used.
Fariborz Jahanian05684072012-04-09 18:58:55 +00002790 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
David Chisnall3154e682011-09-30 13:32:35 +00002791 CmdArgs.push_back("-fobjc-default-synthesize-properties");
2792 }
2793
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00002794 // -fencode-extended-block-signature=1 is default.
2795 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
2796 CmdArgs.push_back("-fencode-extended-block-signature");
2797 }
2798
John McCall24fc0de2011-07-06 00:26:06 +00002799 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
2800 // NOTE: This logic is duplicated in ToolChains.cpp.
2801 bool ARC = isObjCAutoRefCount(Args);
2802 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00002803 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00002804
John McCall24fc0de2011-07-06 00:26:06 +00002805 CmdArgs.push_back("-fobjc-arc");
2806
Chandler Carruth491db322011-11-04 07:34:47 +00002807 // FIXME: It seems like this entire block, and several around it should be
2808 // wrapped in isObjC, but for now we just use it here as this is where it
2809 // was being used previously.
2810 if (types::isCXX(InputType) && types::isObjC(InputType)) {
2811 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2812 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
2813 else
2814 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
2815 }
2816
John McCall24fc0de2011-07-06 00:26:06 +00002817 // Allow the user to enable full exceptions code emission.
2818 // We define off for Objective-CC, on for Objective-C++.
2819 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2820 options::OPT_fno_objc_arc_exceptions,
2821 /*default*/ types::isCXX(InputType)))
2822 CmdArgs.push_back("-fobjc-arc-exceptions");
2823 }
2824
2825 // -fobjc-infer-related-result-type is the default, except in the Objective-C
2826 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00002827 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00002828 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002829
John McCall24fc0de2011-07-06 00:26:06 +00002830 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
2831 // takes precedence.
2832 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
2833 if (!GCArg)
2834 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
2835 if (GCArg) {
2836 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002837 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00002838 << GCArg->getAsString(Args);
2839 } else if (getToolChain().SupportsObjCGC()) {
2840 GCArg->render(Args, CmdArgs);
2841 } else {
2842 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002843 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00002844 << GCArg->getAsString(Args);
2845 }
2846 }
2847
John McCallb5f652e2011-06-22 00:53:57 +00002848 // Add exception args.
2849 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00002850 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00002851
2852 if (getToolChain().UseSjLjExceptions())
2853 CmdArgs.push_back("-fsjlj-exceptions");
2854
2855 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00002856 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2857 options::OPT_fno_assume_sane_operator_new))
2858 CmdArgs.push_back("-fno-assume-sane-operator-new");
2859
Daniel Dunbar34d7a992010-04-27 15:34:57 +00002860 // -fconstant-cfstrings is default, and may be subject to argument translation
2861 // on Darwin.
2862 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2863 options::OPT_fno_constant_cfstrings) ||
2864 !Args.hasFlag(options::OPT_mconstant_cfstrings,
2865 options::OPT_mno_constant_cfstrings))
2866 CmdArgs.push_back("-fno-constant-cfstrings");
2867
John Thompsoned4e2952009-11-05 20:14:16 +00002868 // -fshort-wchar default varies depending on platform; only
2869 // pass if specified.
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00002870 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2871 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00002872
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +00002873 // -fno-pascal-strings is default, only pass non-default. If the tool chain
2874 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbard4510f22009-04-07 23:51:44 +00002875 //
2876 // FIXME: This is gross; that translation should be pulled from the
2877 // tool chain.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002878 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00002879 options::OPT_fno_pascal_strings,
2880 false) ||
2881 Args.hasFlag(options::OPT_mpascal_strings,
2882 options::OPT_mno_pascal_strings,
2883 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002884 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002885
Daniel Dunbar096ed292011-10-05 21:04:55 +00002886 // Honor -fpack-struct= and -fpack-struct, if given. Note that
2887 // -fno-pack-struct doesn't apply to -fpack-struct=.
2888 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00002889 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00002890 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00002891 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00002892 } else if (Args.hasFlag(options::OPT_fpack_struct,
2893 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00002894 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00002895 }
2896
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002897 if (Args.hasArg(options::OPT_mkernel) ||
2898 Args.hasArg(options::OPT_fapple_kext)) {
2899 if (!Args.hasArg(options::OPT_fcommon))
2900 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00002901 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002902 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00002903
Daniel Dunbard18049a2009-04-07 21:16:11 +00002904 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002905 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002906 CmdArgs.push_back("-fno-common");
2907
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002908 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00002909 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00002910 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002911 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002912 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002913 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2914
Daniel Dunbar6358d682010-10-15 22:30:42 +00002915 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2916 if (!Args.hasFlag(options::OPT_ffor_scope,
2917 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002918 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00002919 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2920
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00002921 // -fcaret-diagnostics is default.
2922 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2923 options::OPT_fno_caret_diagnostics, true))
2924 CmdArgs.push_back("-fno-caret-diagnostics");
2925
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002926 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00002927 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002928 options::OPT_fno_diagnostics_fixit_info))
2929 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002930
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002931 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00002932 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002933 options::OPT_fno_diagnostics_show_option))
2934 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002935
Chris Lattnerbf6fac82010-05-04 21:55:25 +00002936 if (const Arg *A =
2937 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2938 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00002939 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00002940 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00002941
Douglas Gregor643c9222011-05-21 17:07:29 +00002942 if (const Arg *A =
2943 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2944 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00002945 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00002946 }
2947
Chandler Carruthb6766f02011-03-27 01:50:55 +00002948 if (Arg *A = Args.getLastArg(
2949 options::OPT_fdiagnostics_show_note_include_stack,
2950 options::OPT_fno_diagnostics_show_note_include_stack)) {
2951 if (A->getOption().matches(
2952 options::OPT_fdiagnostics_show_note_include_stack))
2953 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2954 else
2955 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2956 }
2957
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002958 // Color diagnostics are the default, unless the terminal doesn't support
2959 // them.
2960 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidis4f920162010-09-23 12:56:06 +00002961 options::OPT_fno_color_diagnostics,
2962 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002963 CmdArgs.push_back("-fcolor-diagnostics");
2964
Daniel Dunbardb097022009-06-08 21:13:54 +00002965 if (!Args.hasFlag(options::OPT_fshow_source_location,
2966 options::OPT_fno_show_source_location))
2967 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002968
Douglas Gregor643c9222011-05-21 17:07:29 +00002969 if (!Args.hasFlag(options::OPT_fshow_column,
2970 options::OPT_fno_show_column,
2971 true))
2972 CmdArgs.push_back("-fno-show-column");
2973
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00002974 if (!Args.hasFlag(options::OPT_fspell_checking,
2975 options::OPT_fno_spell_checking))
2976 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00002977
Daniel Dunbar473f8a62010-10-18 22:49:46 +00002978
Chad Rosierc8e56e82012-12-05 21:08:21 +00002979 // -fno-asm-blocks is default.
2980 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2981 false))
2982 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00002983
Nadav Rotem1cd71a72012-12-18 23:10:16 +00002984 // -fvectorize is default.
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00002985 if (Args.hasFlag(options::OPT_fvectorize,
Nadav Rotem1cd71a72012-12-18 23:10:16 +00002986 options::OPT_fno_vectorize, true)) {
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00002987 CmdArgs.push_back("-backend-option");
2988 CmdArgs.push_back("-vectorize-loops");
2989 }
2990
Hal Finkel061f1652012-12-11 19:59:32 +00002991 // -fno-slp-vectorize is default.
2992 if (Args.hasFlag(options::OPT_fslp_vectorize,
2993 options::OPT_fno_slp_vectorize, false)) {
2994 CmdArgs.push_back("-backend-option");
2995 CmdArgs.push_back("-vectorize");
2996 }
2997
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00002998 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2999 A->render(Args, CmdArgs);
3000
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003001 // -fdollars-in-identifiers default varies depending on platform and
3002 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003003 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003004 options::OPT_fno_dollars_in_identifiers)) {
3005 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003006 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003007 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003008 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003009 }
3010
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003011 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3012 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003013 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003014 options::OPT_fno_unit_at_a_time)) {
3015 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003016 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003017 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003018
Eli Friedman055c9702011-11-02 01:53:16 +00003019 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3020 options::OPT_fno_apple_pragma_pack, false))
3021 CmdArgs.push_back("-fapple-pragma-pack");
3022
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003023 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003024 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003025 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003026#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00003027 if (getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003028 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3029 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
3030 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3031 CmdArgs.push_back("-fno-builtin-strcat");
3032 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3033 CmdArgs.push_back("-fno-builtin-strcpy");
3034 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003035#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003036
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003037 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00003038 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003039 options::OPT_traditional_cpp)) {
3040 if (isa<PreprocessJobAction>(JA))
3041 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003042 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003043 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003044 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003045
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003046 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00003047 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003048
3049 // Handle serialized diagnostics.
3050 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3051 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003052 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003053 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003054
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003055 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3056 CmdArgs.push_back("-fretain-comments-from-system-headers");
3057
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003058 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3059 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003060 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003061 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3062 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003063 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003064
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003065 // We translate this by hand to the -cc1 argument, since nightly test uses
3066 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003067 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003068 CmdArgs.push_back("-disable-llvm-optzns");
3069 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003070 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003071 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003072
Daniel Dunbard67a3222009-03-30 06:36:42 +00003073 if (Output.getType() == types::TY_Dependencies) {
3074 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003075 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003076 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003077 CmdArgs.push_back(Output.getFilename());
3078 } else {
3079 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003080 }
3081
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003082 for (InputInfoList::const_iterator
3083 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3084 const InputInfo &II = *it;
3085 CmdArgs.push_back("-x");
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00003086 if (Args.hasArg(options::OPT_rewrite_objc))
3087 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3088 else
3089 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbarb440f562010-08-02 02:38:21 +00003090 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003091 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003092 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003093 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003094 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003095
Chris Lattnere9d7d782009-11-03 19:50:27 +00003096 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3097
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003098 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003099
3100 // Optionally embed the -cc1 level arguments into the debug info, for build
3101 // analysis.
3102 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003103 ArgStringList OriginalArgs;
3104 for (ArgList::const_iterator it = Args.begin(),
3105 ie = Args.end(); it != ie; ++it)
3106 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003107
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003108 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003109 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003110 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003111 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003112 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003113 }
3114 CmdArgs.push_back("-dwarf-debug-flags");
3115 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3116 }
3117
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003118 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar17731772009-03-23 19:03:36 +00003119
Roman Divacky178e01602011-02-10 16:52:03 +00003120 if (Arg *A = Args.getLastArg(options::OPT_pg))
3121 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003122 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003123 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003124
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003125 // Claim some arguments which clang supports automatically.
3126
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003127 // -fpch-preprocess is used with gcc to add a special marker in the output to
3128 // include the PCH file. Clang's PTH solution is completely transparent, so we
3129 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003130 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003131
Daniel Dunbar17731772009-03-23 19:03:36 +00003132 // Claim some arguments which clang doesn't support, but we don't
3133 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003134 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3135 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003136
Rafael Espindolad95a8122011-03-01 05:25:27 +00003137 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
Rafael Espindola22f603032011-02-28 23:29:45 +00003138 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003139 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003140}
3141
Jim Grosbach576452b2012-02-10 20:37:10 +00003142void ClangAs::AddARMTargetArgs(const ArgList &Args,
3143 ArgStringList &CmdArgs) const {
3144 const Driver &D = getToolChain().getDriver();
3145 llvm::Triple Triple = getToolChain().getTriple();
3146
3147 // Set the CPU based on -march= and -mcpu=.
3148 CmdArgs.push_back("-target-cpu");
Benjamin Kramer09811c72012-06-26 22:20:06 +00003149 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
Jim Grosbach576452b2012-02-10 20:37:10 +00003150
3151 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +00003152 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +00003153 addFPUArgs(D, A, Args, CmdArgs);
Chad Rosier1f0e52e2012-04-04 20:39:32 +00003154
3155 // Honor -mfpmath=.
3156 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +00003157 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Jim Grosbach576452b2012-02-10 20:37:10 +00003158}
3159
John McCall5fb5df92012-06-20 06:18:46 +00003160/// Add options related to the Objective-C runtime/ABI.
3161///
3162/// Returns true if the runtime is non-fragile.
3163ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3164 ArgStringList &cmdArgs,
3165 RewriteKind rewriteKind) const {
3166 // Look for the controlling runtime option.
3167 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3168 options::OPT_fgnu_runtime,
3169 options::OPT_fobjc_runtime_EQ);
3170
3171 // Just forward -fobjc-runtime= to the frontend. This supercedes
3172 // options about fragility.
3173 if (runtimeArg &&
3174 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3175 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003176 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003177 if (runtime.tryParse(value)) {
3178 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3179 << value;
3180 }
3181
3182 runtimeArg->render(args, cmdArgs);
3183 return runtime;
3184 }
3185
3186 // Otherwise, we'll need the ABI "version". Version numbers are
3187 // slightly confusing for historical reasons:
3188 // 1 - Traditional "fragile" ABI
3189 // 2 - Non-fragile ABI, version 1
3190 // 3 - Non-fragile ABI, version 2
3191 unsigned objcABIVersion = 1;
3192 // If -fobjc-abi-version= is present, use that to set the version.
3193 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003194 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003195 if (value == "1")
3196 objcABIVersion = 1;
3197 else if (value == "2")
3198 objcABIVersion = 2;
3199 else if (value == "3")
3200 objcABIVersion = 3;
3201 else
3202 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3203 << value;
3204 } else {
3205 // Otherwise, determine if we are using the non-fragile ABI.
3206 bool nonFragileABIIsDefault =
3207 (rewriteKind == RK_NonFragile ||
3208 (rewriteKind == RK_None &&
3209 getToolChain().IsObjCNonFragileABIDefault()));
3210 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3211 options::OPT_fno_objc_nonfragile_abi,
3212 nonFragileABIIsDefault)) {
3213 // Determine the non-fragile ABI version to use.
3214#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3215 unsigned nonFragileABIVersion = 1;
3216#else
3217 unsigned nonFragileABIVersion = 2;
3218#endif
3219
3220 if (Arg *abiArg = args.getLastArg(
3221 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003222 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003223 if (value == "1")
3224 nonFragileABIVersion = 1;
3225 else if (value == "2")
3226 nonFragileABIVersion = 2;
3227 else
3228 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3229 << value;
3230 }
3231
3232 objcABIVersion = 1 + nonFragileABIVersion;
3233 } else {
3234 objcABIVersion = 1;
3235 }
3236 }
3237
3238 // We don't actually care about the ABI version other than whether
3239 // it's non-fragile.
3240 bool isNonFragile = objcABIVersion != 1;
3241
3242 // If we have no runtime argument, ask the toolchain for its default runtime.
3243 // However, the rewriter only really supports the Mac runtime, so assume that.
3244 ObjCRuntime runtime;
3245 if (!runtimeArg) {
3246 switch (rewriteKind) {
3247 case RK_None:
3248 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3249 break;
3250 case RK_Fragile:
3251 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3252 break;
3253 case RK_NonFragile:
3254 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3255 break;
3256 }
3257
3258 // -fnext-runtime
3259 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3260 // On Darwin, make this use the default behavior for the toolchain.
3261 if (getToolChain().getTriple().isOSDarwin()) {
3262 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3263
3264 // Otherwise, build for a generic macosx port.
3265 } else {
3266 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3267 }
3268
3269 // -fgnu-runtime
3270 } else {
3271 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00003272 // Legacy behaviour is to target the gnustep runtime if we are i
3273 // non-fragile mode or the GCC runtime in fragile mode.
3274 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00003275 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00003276 else
3277 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00003278 }
3279
3280 cmdArgs.push_back(args.MakeArgString(
3281 "-fobjc-runtime=" + runtime.getAsString()));
3282 return runtime;
3283}
3284
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003285void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003286 const InputInfo &Output,
3287 const InputInfoList &Inputs,
3288 const ArgList &Args,
3289 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003290 ArgStringList CmdArgs;
3291
3292 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3293 const InputInfo &Input = Inputs[0];
3294
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003295 // Don't warn about "clang -w -c foo.s"
3296 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003297 // and "clang -emit-llvm -c foo.s"
3298 Args.ClaimAllArgs(options::OPT_emit_llvm);
3299 // and "clang -use-gold-plugin -c foo.s"
3300 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003301
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003302 // Invoke ourselves in -cc1as mode.
3303 //
3304 // FIXME: Implement custom jobs for internal actions.
3305 CmdArgs.push_back("-cc1as");
3306
3307 // Add the "effective" target triple.
3308 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00003309 std::string TripleStr =
3310 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003311 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3312
3313 // Set the output mode, we currently only expect to be used as a real
3314 // assembler.
3315 CmdArgs.push_back("-filetype");
3316 CmdArgs.push_back("obj");
3317
Eric Christopher45f2e712012-12-18 00:31:10 +00003318 // Set the main file name, so that debug info works even with
3319 // -save-temps or preprocessed assembly.
3320 CmdArgs.push_back("-main-file-name");
3321 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
3322
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00003323 if (UseRelaxAll(C, Args))
Daniel Dunbar99ca8b72010-05-28 16:43:21 +00003324 CmdArgs.push_back("-relax-all");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003325
Jim Grosbach576452b2012-02-10 20:37:10 +00003326 // Add target specific cpu and features flags.
3327 switch(getToolChain().getTriple().getArch()) {
3328 default:
3329 break;
3330
3331 case llvm::Triple::arm:
3332 case llvm::Triple::thumb:
3333 AddARMTargetArgs(Args, CmdArgs);
3334 break;
3335 }
3336
Daniel Dunbar1d733e22011-03-17 17:37:29 +00003337 // Ignore explicit -force_cpusubtype_ALL option.
3338 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003339
Eric Christopherfc3ee562012-01-10 00:38:01 +00003340 // Determine the original source input.
3341 const Action *SourceAction = &JA;
3342 while (SourceAction->getKind() != Action::InputClass) {
3343 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3344 SourceAction = SourceAction->getInputs()[0];
3345 }
3346
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003347 // Forward -g and handle debug info related flags, assuming we are dealing
3348 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00003349 if (SourceAction->getType() == types::TY_Asm ||
3350 SourceAction->getType() == types::TY_PP_Asm) {
3351 Args.ClaimAllArgs(options::OPT_g_Group);
3352 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3353 if (!A->getOption().matches(options::OPT_g0))
3354 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003355
3356 // Add the -fdebug-compilation-dir flag if needed.
3357 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00003358
3359 // Set the AT_producer to the clang version when using the integrated
3360 // assembler on assembly source files.
3361 CmdArgs.push_back("-dwarf-debug-producer");
3362 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00003363 }
Kevin Enderby292dc082011-12-22 19:31:58 +00003364
3365 // Optionally embed the -cc1as level arguments into the debug info, for build
3366 // analysis.
3367 if (getToolChain().UseDwarfDebugFlags()) {
3368 ArgStringList OriginalArgs;
3369 for (ArgList::const_iterator it = Args.begin(),
3370 ie = Args.end(); it != ie; ++it)
3371 (*it)->render(Args, OriginalArgs);
3372
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003373 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00003374 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3375 Flags += Exec;
3376 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3377 Flags += " ";
3378 Flags += OriginalArgs[i];
3379 }
3380 CmdArgs.push_back("-dwarf-debug-flags");
3381 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3382 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003383
3384 // FIXME: Add -static support, once we have it.
3385
3386 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3387 options::OPT_Xassembler);
Daniel Dunbar252e8f92011-04-29 17:53:18 +00003388 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003389
3390 assert(Output.isFilename() && "Unexpected lipo output.");
3391 CmdArgs.push_back("-o");
3392 CmdArgs.push_back(Output.getFilename());
3393
Daniel Dunbarb440f562010-08-02 02:38:21 +00003394 assert(Input.isFilename() && "Invalid input.");
3395 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003396
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003397 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003398 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003399}
3400
Daniel Dunbara3246a02009-03-18 08:07:30 +00003401void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003402 const InputInfo &Output,
3403 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003404 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003405 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003406 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003407 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003408
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003409 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003410 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003411 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00003412 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00003413 // Don't forward any -g arguments to assembly steps.
3414 if (isa<AssembleJobAction>(JA) &&
3415 A->getOption().matches(options::OPT_g_Group))
3416 continue;
3417
Daniel Dunbar2da02722009-03-19 07:55:12 +00003418 // It is unfortunate that we have to claim here, as this means
3419 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00003420 // platforms using a generic gcc, even if we are just using gcc
3421 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00003422 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003423 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00003424 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003425 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003426
Daniel Dunbar4e295052010-01-25 22:35:08 +00003427 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003428
3429 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003430 llvm::Triple::ArchType Arch = getToolChain().getArch();
Bob Wilson6524dd32011-10-14 05:03:44 +00003431 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003432 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00003433
3434 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003435 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003436 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003437 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003438 CmdArgs.push_back("ppc64");
3439 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003440 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00003441 }
3442
Daniel Dunbar5716d872009-05-02 21:41:52 +00003443 // Try to force gcc to match the tool chain we want, if we recognize
3444 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003445 //
3446 // FIXME: The triple class should directly provide the information we want
3447 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003448 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003449 CmdArgs.push_back("-m32");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003450 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86_64)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003451 CmdArgs.push_back("-m64");
3452
Daniel Dunbarb440f562010-08-02 02:38:21 +00003453 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003454 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003455 CmdArgs.push_back(Output.getFilename());
3456 } else {
3457 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003458 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003459 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003460
Tony Linthicum76329bf2011-12-12 21:14:55 +00003461 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3462 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003463
3464 // Only pass -x if gcc will understand it; otherwise hope gcc
3465 // understands the suffix correctly. The main use case this would go
3466 // wrong in is for linker inputs if they happened to have an odd
3467 // suffix; really the only way to get this to happen is a command
3468 // like '-x foobar a.c' which will treat a.c like a linker input.
3469 //
3470 // FIXME: For the linker case specifically, can we safely convert
3471 // inputs into '-Wl,' options?
3472 for (InputInfoList::const_iterator
3473 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3474 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003475
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003476 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003477 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3478 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003479 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003480 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003481 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003482 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003483 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003484
Daniel Dunbara3246a02009-03-18 08:07:30 +00003485 if (types::canTypeBeUserSpecified(II.getType())) {
3486 CmdArgs.push_back("-x");
3487 CmdArgs.push_back(types::getTypeName(II.getType()));
3488 }
3489
Daniel Dunbarb440f562010-08-02 02:38:21 +00003490 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003491 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00003492 else {
3493 const Arg &A = II.getInputArg();
3494
3495 // Reverse translate some rewritten options.
3496 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
3497 CmdArgs.push_back("-lstdc++");
3498 continue;
3499 }
3500
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003501 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00003502 A.render(Args, CmdArgs);
3503 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003504 }
3505
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003506 const std::string customGCCName = D.getCCCGenericGCCName();
3507 const char *GCCName;
3508 if (!customGCCName.empty())
3509 GCCName = customGCCName.c_str();
3510 else if (D.CCCIsCXX) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003511 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003512 } else
3513 GCCName = "gcc";
3514
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003515 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003516 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003517 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003518}
3519
Daniel Dunbar4e295052010-01-25 22:35:08 +00003520void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
3521 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003522 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003523}
3524
Daniel Dunbar4e295052010-01-25 22:35:08 +00003525void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
3526 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003527 // The type is good enough.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003528}
3529
Daniel Dunbar4e295052010-01-25 22:35:08 +00003530void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
3531 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003532 const Driver &D = getToolChain().getDriver();
3533
Daniel Dunbar4e295052010-01-25 22:35:08 +00003534 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003535 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
3536 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00003537 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003538 else {
3539 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003540 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003541 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003542
Daniel Dunbar4e295052010-01-25 22:35:08 +00003543 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003544 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003545}
3546
Daniel Dunbar4e295052010-01-25 22:35:08 +00003547void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
3548 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003549 CmdArgs.push_back("-c");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003550}
Daniel Dunbara3246a02009-03-18 08:07:30 +00003551
Daniel Dunbar4e295052010-01-25 22:35:08 +00003552void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
3553 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003554 // The types are (hopefully) good enough.
3555}
3556
Tony Linthicum76329bf2011-12-12 21:14:55 +00003557// Hexagon tools start.
3558void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
3559 ArgStringList &CmdArgs) const {
3560
3561}
3562void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3563 const InputInfo &Output,
3564 const InputInfoList &Inputs,
3565 const ArgList &Args,
3566 const char *LinkingOutput) const {
3567
3568 const Driver &D = getToolChain().getDriver();
3569 ArgStringList CmdArgs;
3570
3571 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00003572 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00003573 CmdArgs.push_back(Args.MakeArgString(MarchString));
3574
3575 RenderExtraToolArgs(JA, CmdArgs);
3576
3577 if (Output.isFilename()) {
3578 CmdArgs.push_back("-o");
3579 CmdArgs.push_back(Output.getFilename());
3580 } else {
3581 assert(Output.isNothing() && "Unexpected output");
3582 CmdArgs.push_back("-fsyntax-only");
3583 }
3584
Matthew Curtise8f80a12012-12-06 17:49:03 +00003585 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
3586 if (!SmallDataThreshold.empty())
3587 CmdArgs.push_back(
3588 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00003589
Matthew Curtise5df3812012-12-07 17:23:04 +00003590 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
3591 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3592 options::OPT_Xassembler);
3593
Tony Linthicum76329bf2011-12-12 21:14:55 +00003594 // Only pass -x if gcc will understand it; otherwise hope gcc
3595 // understands the suffix correctly. The main use case this would go
3596 // wrong in is for linker inputs if they happened to have an odd
3597 // suffix; really the only way to get this to happen is a command
3598 // like '-x foobar a.c' which will treat a.c like a linker input.
3599 //
3600 // FIXME: For the linker case specifically, can we safely convert
3601 // inputs into '-Wl,' options?
3602 for (InputInfoList::const_iterator
3603 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3604 const InputInfo &II = *it;
3605
3606 // Don't try to pass LLVM or AST inputs to a generic gcc.
3607 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3608 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3609 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3610 << getToolChain().getTripleString();
3611 else if (II.getType() == types::TY_AST)
3612 D.Diag(clang::diag::err_drv_no_ast_support)
3613 << getToolChain().getTripleString();
3614
3615 if (II.isFilename())
3616 CmdArgs.push_back(II.getFilename());
3617 else
3618 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3619 II.getInputArg().render(Args, CmdArgs);
3620 }
3621
3622 const char *GCCName = "hexagon-as";
3623 const char *Exec =
3624 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3625 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3626
3627}
3628void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
3629 ArgStringList &CmdArgs) const {
3630 // The types are (hopefully) good enough.
3631}
3632
3633void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
3634 const InputInfo &Output,
3635 const InputInfoList &Inputs,
3636 const ArgList &Args,
3637 const char *LinkingOutput) const {
3638
Matthew Curtise689b052012-12-06 15:46:07 +00003639 const toolchains::Hexagon_TC& ToolChain =
3640 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
3641 const Driver &D = ToolChain.getDriver();
3642
Tony Linthicum76329bf2011-12-12 21:14:55 +00003643 ArgStringList CmdArgs;
3644
Matthew Curtise689b052012-12-06 15:46:07 +00003645 //----------------------------------------------------------------------------
3646 //
3647 //----------------------------------------------------------------------------
3648 bool hasStaticArg = Args.hasArg(options::OPT_static);
3649 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00003650 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00003651 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
3652 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
3653 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
3654 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003655
Matthew Curtise689b052012-12-06 15:46:07 +00003656 //----------------------------------------------------------------------------
3657 // Silence warnings for various options
3658 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00003659
Matthew Curtise689b052012-12-06 15:46:07 +00003660 Args.ClaimAllArgs(options::OPT_g_Group);
3661 Args.ClaimAllArgs(options::OPT_emit_llvm);
3662 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
3663 // handled somewhere else.
3664 Args.ClaimAllArgs(options::OPT_static_libgcc);
3665
3666 //----------------------------------------------------------------------------
3667 //
3668 //----------------------------------------------------------------------------
3669 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
3670 e = ToolChain.ExtraOpts.end();
3671 i != e; ++i)
3672 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00003673
Matthew Curtisf10a5952012-12-06 14:16:43 +00003674 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
3675 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00003676
Matthew Curtise689b052012-12-06 15:46:07 +00003677 if (buildingLib) {
3678 CmdArgs.push_back("-shared");
3679 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
3680 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00003681 }
3682
Matthew Curtise689b052012-12-06 15:46:07 +00003683 if (hasStaticArg)
3684 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00003685
Matthew Curtise8f80a12012-12-06 17:49:03 +00003686 if (buildPIE && !buildingLib)
3687 CmdArgs.push_back("-pie");
3688
3689 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
3690 if (!SmallDataThreshold.empty()) {
3691 CmdArgs.push_back(
3692 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
3693 }
3694
Matthew Curtise689b052012-12-06 15:46:07 +00003695 //----------------------------------------------------------------------------
3696 //
3697 //----------------------------------------------------------------------------
3698 CmdArgs.push_back("-o");
3699 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00003700
Matthew Curtise689b052012-12-06 15:46:07 +00003701 const std::string MarchSuffix = "/" + MarchString;
3702 const std::string G0Suffix = "/G0";
3703 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
3704 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
3705 + "/";
3706 const std::string StartFilesDir = RootDir
3707 + "hexagon/lib"
3708 + (buildingLib
3709 ? MarchG0Suffix : MarchSuffix);
3710
3711 //----------------------------------------------------------------------------
3712 // moslib
3713 //----------------------------------------------------------------------------
3714 std::vector<std::string> oslibs;
3715 bool hasStandalone= false;
3716
3717 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
3718 ie = Args.filtered_end(); it != ie; ++it) {
3719 (*it)->claim();
3720 oslibs.push_back((*it)->getValue());
3721 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00003722 }
Matthew Curtise689b052012-12-06 15:46:07 +00003723 if (oslibs.empty()) {
3724 oslibs.push_back("standalone");
3725 hasStandalone = true;
3726 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00003727
Matthew Curtise689b052012-12-06 15:46:07 +00003728 //----------------------------------------------------------------------------
3729 // Start Files
3730 //----------------------------------------------------------------------------
3731 if (incStdLib && incStartFiles) {
3732
3733 if (!buildingLib) {
3734 if (hasStandalone) {
3735 CmdArgs.push_back(
3736 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
3737 }
3738 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
3739 }
3740 std::string initObj = useShared ? "/initS.o" : "/init.o";
3741 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
3742 }
3743
3744 //----------------------------------------------------------------------------
3745 // Library Search Paths
3746 //----------------------------------------------------------------------------
3747 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
3748 for (ToolChain::path_list::const_iterator
3749 i = LibPaths.begin(),
3750 e = LibPaths.end();
3751 i != e;
3752 ++i)
3753 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
3754
3755 //----------------------------------------------------------------------------
3756 //
3757 //----------------------------------------------------------------------------
3758 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3759 Args.AddAllArgs(CmdArgs, options::OPT_e);
3760 Args.AddAllArgs(CmdArgs, options::OPT_s);
3761 Args.AddAllArgs(CmdArgs, options::OPT_t);
3762 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
3763
3764 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
3765
3766 //----------------------------------------------------------------------------
3767 // Libraries
3768 //----------------------------------------------------------------------------
3769 if (incStdLib && incDefLibs) {
3770 if (D.CCCIsCXX) {
3771 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
3772 CmdArgs.push_back("-lm");
3773 }
3774
3775 CmdArgs.push_back("--start-group");
3776
3777 if (!buildingLib) {
3778 for(std::vector<std::string>::iterator i = oslibs.begin(),
3779 e = oslibs.end(); i != e; ++i)
3780 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
3781 CmdArgs.push_back("-lc");
3782 }
3783 CmdArgs.push_back("-lgcc");
3784
3785 CmdArgs.push_back("--end-group");
3786 }
3787
3788 //----------------------------------------------------------------------------
3789 // End files
3790 //----------------------------------------------------------------------------
3791 if (incStdLib && incStartFiles) {
3792 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
3793 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
3794 }
3795
3796 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
3797 C.addCommand(
3798 new Command(
3799 JA, *this,
3800 Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00003801}
3802// Hexagon tools end.
3803
Rafael Espindoladcbf6982012-10-31 18:51:07 +00003804llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
3805 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
3806 // archs which Darwin doesn't use.
3807
3808 // The matching this routine does is fairly pointless, since it is neither the
3809 // complete architecture list, nor a reasonable subset. The problem is that
3810 // historically the driver driver accepts this and also ties its -march=
3811 // handling to the architecture name, so we need to be careful before removing
3812 // support for it.
3813
3814 // This code must be kept in sync with Clang's Darwin specific argument
3815 // translation.
3816
3817 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
3818 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
3819 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
3820 .Case("ppc64", llvm::Triple::ppc64)
3821 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
3822 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
3823 llvm::Triple::x86)
3824 .Case("x86_64", llvm::Triple::x86_64)
3825 // This is derived from the driver driver.
3826 .Cases("arm", "armv4t", "armv5", "armv6", llvm::Triple::arm)
3827 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", llvm::Triple::arm)
3828 .Case("r600", llvm::Triple::r600)
3829 .Case("nvptx", llvm::Triple::nvptx)
3830 .Case("nvptx64", llvm::Triple::nvptx64)
3831 .Case("amdil", llvm::Triple::amdil)
3832 .Case("spir", llvm::Triple::spir)
3833 .Default(llvm::Triple::UnknownArch);
3834}
Tony Linthicum76329bf2011-12-12 21:14:55 +00003835
Bob Wilsondecc03e2012-11-23 06:14:39 +00003836const char *Clang::getBaseInputName(const ArgList &Args,
3837 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00003838 return Args.MakeArgString(
3839 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003840}
3841
Bob Wilsondecc03e2012-11-23 06:14:39 +00003842const char *Clang::getBaseInputStem(const ArgList &Args,
3843 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003844 const char *Str = getBaseInputName(Args, Inputs);
3845
Chris Lattner906bb902011-01-16 08:14:11 +00003846 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003847 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003848
3849 return Str;
3850}
3851
Bob Wilsondecc03e2012-11-23 06:14:39 +00003852const char *Clang::getDependencyFileName(const ArgList &Args,
3853 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003854 // FIXME: Think about this more.
3855 std::string Res;
3856
3857 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003858 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003859 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003860 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00003861 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003862 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003863 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003864}
3865
Daniel Dunbarbe220842009-03-20 16:06:39 +00003866void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003867 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003868 const InputInfoList &Inputs,
3869 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00003870 const char *LinkingOutput) const {
3871 ArgStringList CmdArgs;
3872
3873 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3874 const InputInfo &Input = Inputs[0];
3875
Daniel Dunbardc8355e2011-04-12 23:59:20 +00003876 // Determine the original source input.
3877 const Action *SourceAction = &JA;
3878 while (SourceAction->getKind() != Action::InputClass) {
3879 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3880 SourceAction = SourceAction->getInputs()[0];
3881 }
3882
3883 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00003884 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00003885 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00003886 if (Args.hasArg(options::OPT_gstabs))
3887 CmdArgs.push_back("--gstabs");
3888 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00003889 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00003890 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003891
Daniel Dunbarbe220842009-03-20 16:06:39 +00003892 // Derived from asm spec.
Daniel Dunbar3571dd92009-09-09 18:36:27 +00003893 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00003894
Daniel Dunbar6d484762010-07-22 01:47:22 +00003895 // Use -force_cpusubtype_ALL on x86 by default.
3896 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
3897 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00003898 Args.hasArg(options::OPT_force__cpusubtype__ALL))
3899 CmdArgs.push_back("-force_cpusubtype_ALL");
3900
Daniel Dunbara6b4a3d2009-08-24 22:26:16 +00003901 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00003902 (((Args.hasArg(options::OPT_mkernel) ||
3903 Args.hasArg(options::OPT_fapple_kext)) &&
3904 (!getDarwinToolChain().isTargetIPhoneOS() ||
3905 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
3906 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003907 CmdArgs.push_back("-static");
3908
Daniel Dunbarbe220842009-03-20 16:06:39 +00003909 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3910 options::OPT_Xassembler);
3911
3912 assert(Output.isFilename() && "Unexpected lipo output.");
3913 CmdArgs.push_back("-o");
3914 CmdArgs.push_back(Output.getFilename());
3915
Daniel Dunbarb440f562010-08-02 02:38:21 +00003916 assert(Input.isFilename() && "Invalid input.");
3917 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00003918
3919 // asm_final spec is empty.
3920
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003921 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003922 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003923 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00003924}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00003925
David Blaikie68e081d2011-12-20 02:48:34 +00003926void darwin::DarwinTool::anchor() {}
3927
Daniel Dunbare9ded432009-09-09 18:36:20 +00003928void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
3929 ArgStringList &CmdArgs) const {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003930 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00003931
Daniel Dunbarc1964212009-03-26 16:23:12 +00003932 // Derived from darwin_arch spec.
3933 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00003934 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00003935
Daniel Dunbardcc3b652010-01-22 02:04:58 +00003936 // FIXME: Is this needed anymore?
3937 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00003938 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00003939}
3940
Bill Wendling3b2000f2012-10-02 18:02:50 +00003941bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
3942 // We only need to generate a temp path for LTO if we aren't compiling object
3943 // files. When compiling source files, we run 'dsymutil' after linking. We
3944 // don't run 'dsymutil' when compiling object files.
3945 for (InputInfoList::const_iterator
3946 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
3947 if (it->getType() != types::TY_Object)
3948 return true;
3949
3950 return false;
3951}
3952
Daniel Dunbarccbc4522010-09-09 21:51:05 +00003953void darwin::Link::AddLinkArgs(Compilation &C,
3954 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00003955 ArgStringList &CmdArgs,
3956 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003957 const Driver &D = getToolChain().getDriver();
Daniel Dunbarc44d3132011-04-28 21:23:41 +00003958 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00003959
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003960 unsigned Version[3] = { 0, 0, 0 };
3961 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3962 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00003963 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003964 Version[1], Version[2], HadExtra) ||
3965 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003966 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003967 << A->getAsString(Args);
3968 }
3969
3970 // Newer linkers support -demangle, pass it if supported and not disabled by
3971 // the user.
Daniel Dunbarecb41cb2012-01-04 21:45:27 +00003972 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00003973 // Don't pass -demangle to ld_classic.
3974 //
3975 // FIXME: This is a temporary workaround, ld should be handling this.
3976 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
3977 Args.hasArg(options::OPT_static));
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00003978 if (getToolChain().getArch() == llvm::Triple::x86) {
3979 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
3980 options::OPT_Wl_COMMA),
3981 ie = Args.filtered_end(); it != ie; ++it) {
3982 const Arg *A = *it;
3983 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Richard Smithbd55daf2012-11-01 04:30:05 +00003984 if (StringRef(A->getValue(i)) == "-kext")
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00003985 UsesLdClassic = true;
3986 }
3987 }
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00003988 if (!UsesLdClassic)
3989 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00003990 }
3991
Bill Wendling313b6bf2012-11-16 23:03:00 +00003992 // If we are using LTO, then automatically create a temporary file path for
3993 // the linker to use, so that it's lifetime will extend past a possible
3994 // dsymutil step.
3995 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
3996 const char *TmpPath = C.getArgs().MakeArgString(
3997 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
3998 C.addTempFile(TmpPath);
3999 CmdArgs.push_back("-object_path_lto");
4000 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00004001 }
4002
Daniel Dunbarc1964212009-03-26 16:23:12 +00004003 // Derived from the "link" spec.
4004 Args.AddAllArgs(CmdArgs, options::OPT_static);
4005 if (!Args.hasArg(options::OPT_static))
4006 CmdArgs.push_back("-dynamic");
4007 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4008 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4009 // here. How do we wish to handle such things?
4010 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004011
Daniel Dunbarc1964212009-03-26 16:23:12 +00004012 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara48823f2010-01-22 02:04:52 +00004013 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00004014 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00004015 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004016
4017 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4018 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4019 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4020
4021 Arg *A;
4022 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4023 (A = Args.getLastArg(options::OPT_current__version)) ||
4024 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004025 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00004026 << A->getAsString(Args) << "-dynamiclib";
4027
4028 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4029 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4030 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4031 } else {
4032 CmdArgs.push_back("-dylib");
4033
4034 Arg *A;
4035 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4036 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4037 (A = Args.getLastArg(options::OPT_client__name)) ||
4038 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4039 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4040 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004041 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00004042 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004043
Daniel Dunbarc1964212009-03-26 16:23:12 +00004044 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4045 "-dylib_compatibility_version");
4046 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4047 "-dylib_current_version");
4048
Daniel Dunbara48823f2010-01-22 02:04:52 +00004049 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004050
4051 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4052 "-dylib_install_name");
4053 }
4054
4055 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4056 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4057 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004058 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004059 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004060 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4061 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4062 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4063 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4064 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4065 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00004066 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004067 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4068 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4069 Args.AddAllArgs(CmdArgs, options::OPT_init);
4070
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004071 // Add the deployment target.
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00004072 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
Daniel Dunbar72ceb922011-04-30 04:22:58 +00004073
4074 // If we had an explicit -mios-simulator-version-min argument, honor that,
4075 // otherwise use the traditional deployment targets. We can't just check the
4076 // is-sim attribute because existing code follows this path, and the linker
4077 // may not handle the argument.
4078 //
4079 // FIXME: We may be able to remove this, once we can verify no one depends on
4080 // it.
4081 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4082 CmdArgs.push_back("-ios_simulator_version_min");
4083 else if (DarwinTC.isTargetIPhoneOS())
4084 CmdArgs.push_back("-iphoneos_version_min");
4085 else
4086 CmdArgs.push_back("-macosx_version_min");
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00004087 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004088
Daniel Dunbarc1964212009-03-26 16:23:12 +00004089 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4090 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4091 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4092 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4093 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004094
Daniel Dunbaraf68a882010-07-13 23:31:40 +00004095 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4096 options::OPT_fno_pie,
4097 options::OPT_fno_PIE)) {
4098 if (A->getOption().matches(options::OPT_fpie) ||
4099 A->getOption().matches(options::OPT_fPIE))
4100 CmdArgs.push_back("-pie");
4101 else
4102 CmdArgs.push_back("-no_pie");
4103 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004104
4105 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4106 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4107 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4108 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4109 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4110 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4111 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4112 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4113 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4114 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4115 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4116 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4117 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4118 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4119 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4120 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004121
Daniel Dunbar84384642011-05-02 21:03:47 +00004122 // Give --sysroot= preference, over the Apple specific behavior to also use
4123 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00004124 StringRef sysroot = C.getSysRoot();
4125 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00004126 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00004127 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00004128 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4129 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00004130 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004131 }
4132
Daniel Dunbarc1964212009-03-26 16:23:12 +00004133 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4134 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4135 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4136 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4137 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004138 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004139 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4140 Args.AddAllArgs(CmdArgs, options::OPT_y);
4141 Args.AddLastArg(CmdArgs, options::OPT_w);
4142 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4143 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4144 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4145 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4146 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4147 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4148 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4149 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4150 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4151 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4152 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4153 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4154}
4155
4156void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004157 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004158 const InputInfoList &Inputs,
4159 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00004160 const char *LinkingOutput) const {
4161 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00004162
Daniel Dunbarc1964212009-03-26 16:23:12 +00004163 // The logic here is derived from gcc's behavior; most of which
4164 // comes from specs (starting with link_command). Consult gcc for
4165 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00004166 ArgStringList CmdArgs;
4167
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00004168 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4169 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4170 options::OPT_ccc_arcmt_migrate)) {
4171 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4172 (*I)->claim();
4173 const char *Exec =
4174 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4175 CmdArgs.push_back(Output.getFilename());
4176 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4177 return;
4178 }
4179
Daniel Dunbarc1964212009-03-26 16:23:12 +00004180 // I'm not sure why this particular decomposition exists in gcc, but
4181 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00004182 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004183
Daniel Dunbarc1964212009-03-26 16:23:12 +00004184 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4185 Args.AddAllArgs(CmdArgs, options::OPT_s);
4186 Args.AddAllArgs(CmdArgs, options::OPT_t);
4187 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4188 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004189 Args.AddLastArg(CmdArgs, options::OPT_e);
4190 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4191 Args.AddAllArgs(CmdArgs, options::OPT_r);
4192
Daniel Dunbar767bbab2010-10-18 22:08:36 +00004193 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4194 // members of static archive libraries which implement Objective-C classes or
4195 // categories.
4196 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4197 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004198
Bill Wendling58979742012-12-10 21:48:41 +00004199 if (Args.hasArg(options::OPT_rdynamic))
4200 CmdArgs.push_back("-export_dynamic");
4201
Daniel Dunbarc1964212009-03-26 16:23:12 +00004202 CmdArgs.push_back("-o");
4203 CmdArgs.push_back(Output.getFilename());
4204
Chad Rosier06fd3c62012-05-16 23:45:12 +00004205 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004206 !Args.hasArg(options::OPT_nostartfiles)) {
4207 // Derived from startfile spec.
4208 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004209 // Derived from darwin_dylib1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004210 if (getDarwinToolChain().isTargetIOSSimulator()) {
4211 // The simulator doesn't have a versioned crt1 file.
4212 CmdArgs.push_back("-ldylib1.o");
4213 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004214 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4215 CmdArgs.push_back("-ldylib1.o");
4216 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004217 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbar83608032010-01-27 00:56:56 +00004218 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004219 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004220 CmdArgs.push_back("-ldylib1.10.5.o");
4221 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004222 } else {
4223 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004224 if (!Args.hasArg(options::OPT_static)) {
4225 // Derived from darwin_bundle1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004226 if (getDarwinToolChain().isTargetIOSSimulator()) {
4227 // The simulator doesn't have a versioned crt1 file.
4228 CmdArgs.push_back("-lbundle1.o");
4229 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004230 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4231 CmdArgs.push_back("-lbundle1.o");
4232 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004233 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004234 CmdArgs.push_back("-lbundle1.o");
4235 }
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004236 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004237 } else {
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004238 if (Args.hasArg(options::OPT_pg) &&
4239 getToolChain().SupportsProfiling()) {
Daniel Dunbarc1964212009-03-26 16:23:12 +00004240 if (Args.hasArg(options::OPT_static) ||
4241 Args.hasArg(options::OPT_object) ||
4242 Args.hasArg(options::OPT_preload)) {
4243 CmdArgs.push_back("-lgcrt0.o");
4244 } else {
4245 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004246
Daniel Dunbarc1964212009-03-26 16:23:12 +00004247 // darwin_crt2 spec is empty.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004248 }
Bob Wilsonef285b42012-07-04 00:18:41 +00004249 // By default on OS X 10.8 and later, we don't link with a crt1.o
4250 // file and the linker knows to use _main as the entry point. But,
4251 // when compiling with -pg, we need to link with the gcrt1.o file,
4252 // so pass the -no_new_main option to tell the linker to use the
4253 // "start" symbol as the entry point.
Bob Wilson1e148fe2012-07-03 20:42:10 +00004254 if (getDarwinToolChain().isTargetMacOS() &&
4255 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4256 CmdArgs.push_back("-no_new_main");
Daniel Dunbarc1964212009-03-26 16:23:12 +00004257 } else {
4258 if (Args.hasArg(options::OPT_static) ||
4259 Args.hasArg(options::OPT_object) ||
4260 Args.hasArg(options::OPT_preload)) {
4261 CmdArgs.push_back("-lcrt0.o");
4262 } else {
4263 // Derived from darwin_crt1 spec.
Daniel Dunbarebc34df2011-03-31 17:12:33 +00004264 if (getDarwinToolChain().isTargetIOSSimulator()) {
4265 // The simulator doesn't have a versioned crt1 file.
4266 CmdArgs.push_back("-lcrt1.o");
4267 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004268 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4269 CmdArgs.push_back("-lcrt1.o");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004270 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
Daniel Dunbar83608032010-01-27 00:56:56 +00004271 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004272 } else {
4273 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4274 CmdArgs.push_back("-lcrt1.o");
4275 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4276 CmdArgs.push_back("-lcrt1.10.5.o");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004277 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004278 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004279
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004280 // darwin_crt2 spec is empty.
4281 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004282 }
4283 }
4284 }
4285 }
4286
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004287 if (!getDarwinToolChain().isTargetIPhoneOS() &&
4288 Args.hasArg(options::OPT_shared_libgcc) &&
4289 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004290 const char *Str =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004291 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004292 CmdArgs.push_back(Str);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004293 }
4294 }
4295
4296 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004297
Alexey Samsonov627b10f2012-11-06 15:09:03 +00004298 SanitizerArgs Sanitize(getToolChain().getDriver(), Args);
Alexey Samsonovcc429802012-11-16 12:53:14 +00004299 // If we're building a dynamic lib with -fsanitize=address, or
4300 // -fsanitize=undefined, unresolved symbols may appear. Mark all
4301 // of them as dynamic_lookup. Linking executables is handled in
4302 // lib/Driver/ToolChains.cpp.
4303 if (Sanitize.needsAsanRt() || Sanitize.needsUbsanRt()) {
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00004304 if (Args.hasArg(options::OPT_dynamiclib) ||
4305 Args.hasArg(options::OPT_bundle)) {
4306 CmdArgs.push_back("-undefined");
4307 CmdArgs.push_back("dynamic_lookup");
4308 }
4309 }
4310
Daniel Dunbarc1964212009-03-26 16:23:12 +00004311 if (Args.hasArg(options::OPT_fopenmp))
4312 // This is more complicated in gcc...
4313 CmdArgs.push_back("-lgomp");
4314
Douglas Gregor9295df02012-05-15 21:00:27 +00004315 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4316
Bob Wilson16d93952012-05-15 18:57:39 +00004317 if (isObjCRuntimeLinked(Args) &&
4318 !Args.hasArg(options::OPT_nostdlib) &&
4319 !Args.hasArg(options::OPT_nodefaultlibs)) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004320 // Avoid linking compatibility stubs on i386 mac.
4321 if (!getDarwinToolChain().isTargetMacOS() ||
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004322 getDarwinToolChain().getArch() != llvm::Triple::x86) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004323 // If we don't have ARC or subscripting runtime support, link in the
4324 // runtime stubs. We have to do this *before* adding any of the normal
4325 // linker inputs so that its initializer gets run first.
John McCall5fb5df92012-06-20 06:18:46 +00004326 ObjCRuntime runtime =
4327 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004328 // We use arclite library for both ARC and subscripting support.
John McCall3deb1ad2012-08-21 02:47:43 +00004329 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
John McCall5fb5df92012-06-20 06:18:46 +00004330 !runtime.hasSubscripting())
Ted Kremeneke65b0862012-03-06 20:05:56 +00004331 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004332 }
Bob Wilson7dda0cd2012-04-21 00:21:42 +00004333 CmdArgs.push_back("-framework");
4334 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004335 // Link libobj.
4336 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00004337 }
John McCall31168b02011-06-15 23:02:42 +00004338
Daniel Dunbarc1964212009-03-26 16:23:12 +00004339 if (LinkingOutput) {
4340 CmdArgs.push_back("-arch_multiple");
4341 CmdArgs.push_back("-final_output");
4342 CmdArgs.push_back(LinkingOutput);
4343 }
4344
Daniel Dunbarc1964212009-03-26 16:23:12 +00004345 if (Args.hasArg(options::OPT_fnested_functions))
4346 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004347
Daniel Dunbarc1964212009-03-26 16:23:12 +00004348 if (!Args.hasArg(options::OPT_nostdlib) &&
4349 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004350 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004351 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00004352
Daniel Dunbarc1964212009-03-26 16:23:12 +00004353 // link_ssp spec is empty.
4354
Daniel Dunbar26d482a2009-09-18 08:15:03 +00004355 // Let the tool chain choose which runtime library to link.
4356 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004357 }
4358
Chad Rosier06fd3c62012-05-16 23:45:12 +00004359 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004360 !Args.hasArg(options::OPT_nostartfiles)) {
4361 // endfile_spec is empty.
4362 }
4363
4364 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4365 Args.AddAllArgs(CmdArgs, options::OPT_F);
4366
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004367 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004368 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004369 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00004370}
4371
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004372void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004373 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004374 const InputInfoList &Inputs,
4375 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004376 const char *LinkingOutput) const {
4377 ArgStringList CmdArgs;
4378
4379 CmdArgs.push_back("-create");
4380 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004381
4382 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004383 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004384
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004385 for (InputInfoList::const_iterator
4386 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4387 const InputInfo &II = *it;
4388 assert(II.isFilename() && "Unexpected lipo input.");
4389 CmdArgs.push_back(II.getFilename());
4390 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004391 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004392 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004393 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004394}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004395
Daniel Dunbar88299622010-06-04 18:28:36 +00004396void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004397 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00004398 const InputInfoList &Inputs,
4399 const ArgList &Args,
4400 const char *LinkingOutput) const {
4401 ArgStringList CmdArgs;
4402
Daniel Dunbareb86b042011-05-09 17:23:16 +00004403 CmdArgs.push_back("-o");
4404 CmdArgs.push_back(Output.getFilename());
4405
Daniel Dunbar88299622010-06-04 18:28:36 +00004406 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4407 const InputInfo &Input = Inputs[0];
4408 assert(Input.isFilename() && "Unexpected dsymutil input.");
4409 CmdArgs.push_back(Input.getFilename());
4410
Daniel Dunbar88299622010-06-04 18:28:36 +00004411 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004412 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004413 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00004414}
4415
Eric Christopher551ef452011-08-23 17:56:55 +00004416void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00004417 const InputInfo &Output,
4418 const InputInfoList &Inputs,
4419 const ArgList &Args,
4420 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00004421 ArgStringList CmdArgs;
4422 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00004423 CmdArgs.push_back("--debug-info");
4424 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00004425 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00004426
4427 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4428 const InputInfo &Input = Inputs[0];
4429 assert(Input.isFilename() && "Unexpected verify input");
4430
4431 // Grabbing the output of the earlier dsymutil run.
4432 CmdArgs.push_back(Input.getFilename());
4433
4434 const char *Exec =
4435 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4436 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4437}
4438
David Chisnallf571cde2012-02-15 13:39:01 +00004439void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4440 const InputInfo &Output,
4441 const InputInfoList &Inputs,
4442 const ArgList &Args,
4443 const char *LinkingOutput) const {
4444 ArgStringList CmdArgs;
4445
4446 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4447 options::OPT_Xassembler);
4448
4449 CmdArgs.push_back("-o");
4450 CmdArgs.push_back(Output.getFilename());
4451
4452 for (InputInfoList::const_iterator
4453 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4454 const InputInfo &II = *it;
4455 CmdArgs.push_back(II.getFilename());
4456 }
4457
4458 const char *Exec =
4459 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4460 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4461}
4462
4463
4464void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4465 const InputInfo &Output,
4466 const InputInfoList &Inputs,
4467 const ArgList &Args,
4468 const char *LinkingOutput) const {
4469 // FIXME: Find a real GCC, don't hard-code versions here
4470 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4471 const llvm::Triple &T = getToolChain().getTriple();
4472 std::string LibPath = "/usr/lib/";
4473 llvm::Triple::ArchType Arch = T.getArch();
4474 switch (Arch) {
4475 case llvm::Triple::x86:
4476 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4477 T.getOSName()).str() + "/4.5.2/";
4478 break;
4479 case llvm::Triple::x86_64:
4480 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4481 T.getOSName()).str();
4482 GCCLibPath += "/4.5.2/amd64/";
4483 LibPath += "amd64/";
4484 break;
4485 default:
4486 assert(0 && "Unsupported architecture");
4487 }
4488
4489 ArgStringList CmdArgs;
4490
David Chisnall272a0712012-02-29 15:06:12 +00004491 // Demangle C++ names in errors
4492 CmdArgs.push_back("-C");
4493
David Chisnallf571cde2012-02-15 13:39:01 +00004494 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4495 (!Args.hasArg(options::OPT_shared))) {
4496 CmdArgs.push_back("-e");
4497 CmdArgs.push_back("_start");
4498 }
4499
4500 if (Args.hasArg(options::OPT_static)) {
4501 CmdArgs.push_back("-Bstatic");
4502 CmdArgs.push_back("-dn");
4503 } else {
4504 CmdArgs.push_back("-Bdynamic");
4505 if (Args.hasArg(options::OPT_shared)) {
4506 CmdArgs.push_back("-shared");
4507 } else {
4508 CmdArgs.push_back("--dynamic-linker");
4509 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
4510 }
4511 }
4512
4513 if (Output.isFilename()) {
4514 CmdArgs.push_back("-o");
4515 CmdArgs.push_back(Output.getFilename());
4516 } else {
4517 assert(Output.isNothing() && "Invalid output.");
4518 }
4519
4520 if (!Args.hasArg(options::OPT_nostdlib) &&
4521 !Args.hasArg(options::OPT_nostartfiles)) {
4522 if (!Args.hasArg(options::OPT_shared)) {
4523 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
4524 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004525 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004526 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4527 } else {
4528 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004529 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4530 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004531 }
David Chisnallddc4c9d2012-03-13 14:14:54 +00004532 if (getToolChain().getDriver().CCCIsCXX)
4533 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004534 }
4535
4536 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
4537
4538 Args.AddAllArgs(CmdArgs, options::OPT_L);
4539 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4540 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00004541 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00004542
4543 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4544
4545 if (!Args.hasArg(options::OPT_nostdlib) &&
4546 !Args.hasArg(options::OPT_nodefaultlibs)) {
David Chisnall3d127c72012-04-10 11:49:50 +00004547 if (getToolChain().getDriver().CCCIsCXX)
4548 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00004549 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004550 if (!Args.hasArg(options::OPT_shared)) {
4551 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00004552 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00004553 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004554 }
David Chisnallf571cde2012-02-15 13:39:01 +00004555 }
4556
4557 if (!Args.hasArg(options::OPT_nostdlib) &&
4558 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00004559 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004560 }
David Chisnall96de9932012-02-16 16:00:47 +00004561 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004562
4563 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4564
4565 const char *Exec =
4566 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4567 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4568}
4569
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004570void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004571 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004572 const InputInfoList &Inputs,
4573 const ArgList &Args,
4574 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004575 ArgStringList CmdArgs;
4576
4577 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4578 options::OPT_Xassembler);
4579
4580 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004581 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004582
4583 for (InputInfoList::const_iterator
4584 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4585 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004586 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004587 }
4588
4589 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004590 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004591 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004592}
4593
4594void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004595 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004596 const InputInfoList &Inputs,
4597 const ArgList &Args,
4598 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004599 ArgStringList CmdArgs;
4600
4601 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004602 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004603 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004604 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004605 }
4606
4607 if (Args.hasArg(options::OPT_static)) {
4608 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004609 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004610 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004611// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004612 CmdArgs.push_back("-Bdynamic");
4613 if (Args.hasArg(options::OPT_shared)) {
4614 CmdArgs.push_back("-shared");
4615 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00004616 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004617 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
4618 }
4619 }
4620
Daniel Dunbarb440f562010-08-02 02:38:21 +00004621 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004622 CmdArgs.push_back("-o");
4623 CmdArgs.push_back(Output.getFilename());
4624 } else {
4625 assert(Output.isNothing() && "Invalid output.");
4626 }
4627
4628 if (!Args.hasArg(options::OPT_nostdlib) &&
4629 !Args.hasArg(options::OPT_nostartfiles)) {
4630 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004631 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004632 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004633 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004634 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004635 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004636 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004637 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004638 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004639 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004640 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00004641 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004642 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004643 }
4644
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004645 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
4646 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00004647 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004648
4649 Args.AddAllArgs(CmdArgs, options::OPT_L);
4650 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4651 Args.AddAllArgs(CmdArgs, options::OPT_e);
4652
Daniel Dunbar54423b22010-09-17 00:24:54 +00004653 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004654
4655 if (!Args.hasArg(options::OPT_nostdlib) &&
4656 !Args.hasArg(options::OPT_nodefaultlibs)) {
4657 // FIXME: For some reason GCC passes -lgcc before adding
4658 // the default system libraries. Just mimic this for now.
4659 CmdArgs.push_back("-lgcc");
4660
4661 if (Args.hasArg(options::OPT_pthread))
4662 CmdArgs.push_back("-pthread");
4663 if (!Args.hasArg(options::OPT_shared))
4664 CmdArgs.push_back("-lc");
4665 CmdArgs.push_back("-lgcc");
4666 }
4667
4668 if (!Args.hasArg(options::OPT_nostdlib) &&
4669 !Args.hasArg(options::OPT_nostartfiles)) {
4670 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00004671 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004672 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004673 }
4674
Bill Wendling08760582011-06-27 19:15:03 +00004675 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00004676
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004677 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004678 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004679 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004680}
4681
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004682void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004683 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004684 const InputInfoList &Inputs,
4685 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00004686 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004687 ArgStringList CmdArgs;
4688
4689 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4690 options::OPT_Xassembler);
4691
4692 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004693 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004694
4695 for (InputInfoList::const_iterator
4696 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4697 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004698 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004699 }
4700
4701 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004702 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004703 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004704}
4705
4706void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004707 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004708 const InputInfoList &Inputs,
4709 const ArgList &Args,
4710 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004711 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004712 ArgStringList CmdArgs;
4713
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00004714 // Silence warning for "clang -g foo.o -o foo"
4715 Args.ClaimAllArgs(options::OPT_g_Group);
4716 // and "clang -emit-llvm foo.o -o foo"
4717 Args.ClaimAllArgs(options::OPT_emit_llvm);
4718 // and for "clang -w foo.o -o foo". Other warning options are already
4719 // handled somewhere else.
4720 Args.ClaimAllArgs(options::OPT_w);
4721
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004722 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004723 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004724 CmdArgs.push_back("-e");
4725 CmdArgs.push_back("__start");
4726 }
4727
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004728 if (Args.hasArg(options::OPT_static)) {
4729 CmdArgs.push_back("-Bstatic");
4730 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00004731 if (Args.hasArg(options::OPT_rdynamic))
4732 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004733 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004734 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004735 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004736 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004737 } else {
4738 CmdArgs.push_back("-dynamic-linker");
4739 CmdArgs.push_back("/usr/libexec/ld.so");
4740 }
4741 }
4742
Daniel Dunbarb440f562010-08-02 02:38:21 +00004743 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004744 CmdArgs.push_back("-o");
4745 CmdArgs.push_back(Output.getFilename());
4746 } else {
4747 assert(Output.isNothing() && "Invalid output.");
4748 }
4749
4750 if (!Args.hasArg(options::OPT_nostdlib) &&
4751 !Args.hasArg(options::OPT_nostartfiles)) {
4752 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00004753 if (Args.hasArg(options::OPT_pg))
4754 CmdArgs.push_back(Args.MakeArgString(
4755 getToolChain().GetFilePath("gcrt0.o")));
4756 else
4757 CmdArgs.push_back(Args.MakeArgString(
4758 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004759 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004760 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004761 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004762 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004763 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004764 }
4765 }
4766
Edward O'Callaghan5c521462009-10-28 15:13:08 +00004767 std::string Triple = getToolChain().getTripleString();
4768 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004769 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00004770 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004771 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004772
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004773 Args.AddAllArgs(CmdArgs, options::OPT_L);
4774 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4775 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00004776 Args.AddAllArgs(CmdArgs, options::OPT_s);
4777 Args.AddAllArgs(CmdArgs, options::OPT_t);
4778 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4779 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004780
Daniel Dunbar54423b22010-09-17 00:24:54 +00004781 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004782
4783 if (!Args.hasArg(options::OPT_nostdlib) &&
4784 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004785 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004786 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00004787 if (Args.hasArg(options::OPT_pg))
4788 CmdArgs.push_back("-lm_p");
4789 else
4790 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004791 }
4792
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004793 // FIXME: For some reason GCC passes -lgcc before adding
4794 // the default system libraries. Just mimic this for now.
4795 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004796
Eric Christopher17674ec2012-09-13 06:32:34 +00004797 if (Args.hasArg(options::OPT_pthread)) {
4798 if (!Args.hasArg(options::OPT_shared) &&
4799 Args.hasArg(options::OPT_pg))
4800 CmdArgs.push_back("-lpthread_p");
4801 else
4802 CmdArgs.push_back("-lpthread");
4803 }
4804
Chandler Carruth45661652011-12-17 22:32:42 +00004805 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00004806 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00004807 CmdArgs.push_back("-lc_p");
4808 else
4809 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00004810 }
Eric Christopher17674ec2012-09-13 06:32:34 +00004811
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004812 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004813 }
4814
4815 if (!Args.hasArg(options::OPT_nostdlib) &&
4816 !Args.hasArg(options::OPT_nostartfiles)) {
4817 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00004818 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004819 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004820 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00004821 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004822 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004823 }
4824
4825 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004826 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004827 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004828}
Ed Schoutene33194b2009-04-02 19:13:12 +00004829
Eli Friedman9fa28852012-08-08 23:57:20 +00004830void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4831 const InputInfo &Output,
4832 const InputInfoList &Inputs,
4833 const ArgList &Args,
4834 const char *LinkingOutput) const {
4835 ArgStringList CmdArgs;
4836
4837 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4838 options::OPT_Xassembler);
4839
4840 CmdArgs.push_back("-o");
4841 CmdArgs.push_back(Output.getFilename());
4842
4843 for (InputInfoList::const_iterator
4844 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4845 const InputInfo &II = *it;
4846 CmdArgs.push_back(II.getFilename());
4847 }
4848
4849 const char *Exec =
4850 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4851 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4852}
4853
4854void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
4855 const InputInfo &Output,
4856 const InputInfoList &Inputs,
4857 const ArgList &Args,
4858 const char *LinkingOutput) const {
4859 const Driver &D = getToolChain().getDriver();
4860 ArgStringList CmdArgs;
4861
4862 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4863 (!Args.hasArg(options::OPT_shared))) {
4864 CmdArgs.push_back("-e");
4865 CmdArgs.push_back("__start");
4866 }
4867
4868 if (Args.hasArg(options::OPT_static)) {
4869 CmdArgs.push_back("-Bstatic");
4870 } else {
4871 if (Args.hasArg(options::OPT_rdynamic))
4872 CmdArgs.push_back("-export-dynamic");
4873 CmdArgs.push_back("--eh-frame-hdr");
4874 CmdArgs.push_back("-Bdynamic");
4875 if (Args.hasArg(options::OPT_shared)) {
4876 CmdArgs.push_back("-shared");
4877 } else {
4878 CmdArgs.push_back("-dynamic-linker");
4879 CmdArgs.push_back("/usr/libexec/ld.so");
4880 }
4881 }
4882
4883 if (Output.isFilename()) {
4884 CmdArgs.push_back("-o");
4885 CmdArgs.push_back(Output.getFilename());
4886 } else {
4887 assert(Output.isNothing() && "Invalid output.");
4888 }
4889
4890 if (!Args.hasArg(options::OPT_nostdlib) &&
4891 !Args.hasArg(options::OPT_nostartfiles)) {
4892 if (!Args.hasArg(options::OPT_shared)) {
4893 if (Args.hasArg(options::OPT_pg))
4894 CmdArgs.push_back(Args.MakeArgString(
4895 getToolChain().GetFilePath("gcrt0.o")));
4896 else
4897 CmdArgs.push_back(Args.MakeArgString(
4898 getToolChain().GetFilePath("crt0.o")));
4899 CmdArgs.push_back(Args.MakeArgString(
4900 getToolChain().GetFilePath("crtbegin.o")));
4901 } else {
4902 CmdArgs.push_back(Args.MakeArgString(
4903 getToolChain().GetFilePath("crtbeginS.o")));
4904 }
4905 }
4906
4907 Args.AddAllArgs(CmdArgs, options::OPT_L);
4908 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4909 Args.AddAllArgs(CmdArgs, options::OPT_e);
4910
4911 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4912
4913 if (!Args.hasArg(options::OPT_nostdlib) &&
4914 !Args.hasArg(options::OPT_nodefaultlibs)) {
4915 if (D.CCCIsCXX) {
4916 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4917 if (Args.hasArg(options::OPT_pg))
4918 CmdArgs.push_back("-lm_p");
4919 else
4920 CmdArgs.push_back("-lm");
4921 }
4922
Rafael Espindola1ad26f02012-10-23 17:07:31 +00004923 if (Args.hasArg(options::OPT_pthread)) {
4924 if (!Args.hasArg(options::OPT_shared) &&
4925 Args.hasArg(options::OPT_pg))
4926 CmdArgs.push_back("-lpthread_p");
4927 else
4928 CmdArgs.push_back("-lpthread");
4929 }
4930
Eli Friedman9fa28852012-08-08 23:57:20 +00004931 if (!Args.hasArg(options::OPT_shared)) {
4932 if (Args.hasArg(options::OPT_pg))
4933 CmdArgs.push_back("-lc_p");
4934 else
4935 CmdArgs.push_back("-lc");
4936 }
4937
4938 std::string myarch = "-lclang_rt.";
4939 const llvm::Triple &T = getToolChain().getTriple();
4940 llvm::Triple::ArchType Arch = T.getArch();
4941 switch (Arch) {
4942 case llvm::Triple::arm:
4943 myarch += ("arm");
4944 break;
4945 case llvm::Triple::x86:
4946 myarch += ("i386");
4947 break;
4948 case llvm::Triple::x86_64:
4949 myarch += ("amd64");
4950 break;
4951 default:
4952 assert(0 && "Unsupported architecture");
4953 }
4954 CmdArgs.push_back(Args.MakeArgString(myarch));
4955 }
4956
4957 if (!Args.hasArg(options::OPT_nostdlib) &&
4958 !Args.hasArg(options::OPT_nostartfiles)) {
4959 if (!Args.hasArg(options::OPT_shared))
4960 CmdArgs.push_back(Args.MakeArgString(
4961 getToolChain().GetFilePath("crtend.o")));
4962 else
4963 CmdArgs.push_back(Args.MakeArgString(
4964 getToolChain().GetFilePath("crtendS.o")));
4965 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00004966
4967 const char *Exec =
4968 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4969 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00004970}
4971
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004972void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004973 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004974 const InputInfoList &Inputs,
4975 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00004976 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004977 ArgStringList CmdArgs;
4978
Daniel Dunbard854c8d2009-04-01 19:36:32 +00004979 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
4980 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004981 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004982 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004983 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00004984 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004985 else if (getToolChain().getArch() == llvm::Triple::mips ||
4986 getToolChain().getArch() == llvm::Triple::mipsel ||
4987 getToolChain().getArch() == llvm::Triple::mips64 ||
4988 getToolChain().getArch() == llvm::Triple::mips64el) {
4989 StringRef CPUName;
4990 StringRef ABIName;
4991 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004992
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00004993 CmdArgs.push_back("-march");
4994 CmdArgs.push_back(CPUName.data());
4995
4996 // Convert ABI name to the GNU tools acceptable variant.
4997 if (ABIName == "o32")
4998 ABIName = "32";
4999 else if (ABIName == "n64")
5000 ABIName = "64";
5001
5002 CmdArgs.push_back("-mabi");
5003 CmdArgs.push_back(ABIName.data());
5004
5005 if (getToolChain().getArch() == llvm::Triple::mips ||
5006 getToolChain().getArch() == llvm::Triple::mips64)
5007 CmdArgs.push_back("-EB");
5008 else
5009 CmdArgs.push_back("-EL");
5010
5011 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5012 options::OPT_fpic, options::OPT_fno_pic,
5013 options::OPT_fPIE, options::OPT_fno_PIE,
5014 options::OPT_fpie, options::OPT_fno_pie);
5015 if (LastPICArg &&
5016 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5017 LastPICArg->getOption().matches(options::OPT_fpic) ||
5018 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5019 LastPICArg->getOption().matches(options::OPT_fpie))) {
5020 CmdArgs.push_back("-KPIC");
5021 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +00005022 } else if (getToolChain().getArch() == llvm::Triple::arm ||
5023 getToolChain().getArch() == llvm::Triple::thumb) {
5024 CmdArgs.push_back("-mfpu=softvfp");
5025 switch(getToolChain().getTriple().getEnvironment()) {
5026 case llvm::Triple::GNUEABI:
5027 case llvm::Triple::EABI:
5028 break;
5029
5030 default:
5031 CmdArgs.push_back("-matpcs");
5032 }
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005033 }
Eric Christopher0b26a612010-03-02 02:41:08 +00005034
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005035 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5036 options::OPT_Xassembler);
5037
5038 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005039 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005040
5041 for (InputInfoList::const_iterator
5042 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5043 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005044 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005045 }
5046
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005047 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005048 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005049 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005050}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005051
5052void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005053 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005054 const InputInfoList &Inputs,
5055 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005056 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00005057 const toolchains::FreeBSD& ToolChain =
5058 static_cast<const toolchains::FreeBSD&>(getToolChain());
5059 const Driver &D = ToolChain.getDriver();
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005060 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00005061
5062 // Silence warning for "clang -g foo.o -o foo"
5063 Args.ClaimAllArgs(options::OPT_g_Group);
5064 // and "clang -emit-llvm foo.o -o foo"
5065 Args.ClaimAllArgs(options::OPT_emit_llvm);
5066 // and for "clang -w foo.o -o foo". Other warning options are already
5067 // handled somewhere else.
5068 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005069
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005070 if (!D.SysRoot.empty())
5071 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5072
Roman Divackyafe2f232012-08-28 15:09:03 +00005073 if (Args.hasArg(options::OPT_pie))
5074 CmdArgs.push_back("-pie");
5075
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005076 if (Args.hasArg(options::OPT_static)) {
5077 CmdArgs.push_back("-Bstatic");
5078 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005079 if (Args.hasArg(options::OPT_rdynamic))
5080 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005081 CmdArgs.push_back("--eh-frame-hdr");
5082 if (Args.hasArg(options::OPT_shared)) {
5083 CmdArgs.push_back("-Bshareable");
5084 } else {
5085 CmdArgs.push_back("-dynamic-linker");
5086 CmdArgs.push_back("/libexec/ld-elf.so.1");
5087 }
Roman Divackyafe2f232012-08-28 15:09:03 +00005088 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5089 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00005090 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5091 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5092 CmdArgs.push_back("--hash-style=both");
5093 }
5094 }
5095 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005096 }
5097
5098 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5099 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005100 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005101 CmdArgs.push_back("-m");
5102 CmdArgs.push_back("elf_i386_fbsd");
5103 }
5104
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005105 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00005106 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00005107 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00005108 }
5109
Daniel Dunbarb440f562010-08-02 02:38:21 +00005110 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005111 CmdArgs.push_back("-o");
5112 CmdArgs.push_back(Output.getFilename());
5113 } else {
5114 assert(Output.isNothing() && "Invalid output.");
5115 }
5116
5117 if (!Args.hasArg(options::OPT_nostdlib) &&
5118 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00005119 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005120 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00005121 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00005122 crt1 = "gcrt1.o";
5123 else if (Args.hasArg(options::OPT_pie))
5124 crt1 = "Scrt1.o";
5125 else
5126 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005127 }
Roman Divackyafe2f232012-08-28 15:09:03 +00005128 if (crt1)
5129 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5130
5131 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5132
5133 const char *crtbegin = NULL;
5134 if (Args.hasArg(options::OPT_static))
5135 crtbegin = "crtbeginT.o";
5136 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5137 crtbegin = "crtbeginS.o";
5138 else
5139 crtbegin = "crtbegin.o";
5140
5141 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005142 }
5143
5144 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00005145 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00005146 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5147 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005148 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005149 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5150 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00005151 Args.AddAllArgs(CmdArgs, options::OPT_s);
5152 Args.AddAllArgs(CmdArgs, options::OPT_t);
5153 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5154 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005155
Roman Divackyafe2f232012-08-28 15:09:03 +00005156 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005157
5158 if (!Args.hasArg(options::OPT_nostdlib) &&
5159 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00005160 if (D.CCCIsCXX) {
Roman Divackyafe2f232012-08-28 15:09:03 +00005161 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00005162 if (Args.hasArg(options::OPT_pg))
5163 CmdArgs.push_back("-lm_p");
5164 else
5165 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00005166 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005167 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5168 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00005169 if (Args.hasArg(options::OPT_pg))
5170 CmdArgs.push_back("-lgcc_p");
5171 else
5172 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005173 if (Args.hasArg(options::OPT_static)) {
5174 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005175 } else if (Args.hasArg(options::OPT_pg)) {
5176 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005177 } else {
5178 CmdArgs.push_back("--as-needed");
5179 CmdArgs.push_back("-lgcc_s");
5180 CmdArgs.push_back("--no-as-needed");
5181 }
5182
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005183 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00005184 if (Args.hasArg(options::OPT_pg))
5185 CmdArgs.push_back("-lpthread_p");
5186 else
5187 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005188 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005189
Roman Divacky66f22762011-02-10 16:59:40 +00005190 if (Args.hasArg(options::OPT_pg)) {
5191 if (Args.hasArg(options::OPT_shared))
5192 CmdArgs.push_back("-lc");
5193 else
5194 CmdArgs.push_back("-lc_p");
5195 CmdArgs.push_back("-lgcc_p");
5196 } else {
5197 CmdArgs.push_back("-lc");
5198 CmdArgs.push_back("-lgcc");
5199 }
5200
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005201 if (Args.hasArg(options::OPT_static)) {
5202 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005203 } else if (Args.hasArg(options::OPT_pg)) {
5204 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005205 } else {
5206 CmdArgs.push_back("--as-needed");
5207 CmdArgs.push_back("-lgcc_s");
5208 CmdArgs.push_back("--no-as-needed");
5209 }
5210 }
5211
5212 if (!Args.hasArg(options::OPT_nostdlib) &&
5213 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackya3c50242012-09-07 13:36:21 +00005214 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Roman Divackyafe2f232012-08-28 15:09:03 +00005215 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00005216 else
5217 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00005218 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005219 }
5220
Roman Divackyafe2f232012-08-28 15:09:03 +00005221 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005222
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005223 const char *Exec =
Roman Divackyafe2f232012-08-28 15:09:03 +00005224 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005225 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005226}
Daniel Dunbarcc912342009-05-02 18:28:39 +00005227
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005228void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5229 const InputInfo &Output,
5230 const InputInfoList &Inputs,
5231 const ArgList &Args,
5232 const char *LinkingOutput) const {
5233 ArgStringList CmdArgs;
5234
5235 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5236 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005237 if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005238 CmdArgs.push_back("--32");
5239
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005240 // Set byte order explicitly
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005241 if (getToolChain().getArch() == llvm::Triple::mips)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005242 CmdArgs.push_back("-EB");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005243 else if (getToolChain().getArch() == llvm::Triple::mipsel)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005244 CmdArgs.push_back("-EL");
5245
5246 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5247 options::OPT_Xassembler);
5248
5249 CmdArgs.push_back("-o");
5250 CmdArgs.push_back(Output.getFilename());
5251
5252 for (InputInfoList::const_iterator
5253 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5254 const InputInfo &II = *it;
5255 CmdArgs.push_back(II.getFilename());
5256 }
5257
David Chisnallddbd68f2011-09-27 22:03:18 +00005258 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005259 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5260}
5261
5262void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5263 const InputInfo &Output,
5264 const InputInfoList &Inputs,
5265 const ArgList &Args,
5266 const char *LinkingOutput) const {
5267 const Driver &D = getToolChain().getDriver();
5268 ArgStringList CmdArgs;
5269
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005270 if (!D.SysRoot.empty())
5271 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5272
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005273 if (Args.hasArg(options::OPT_static)) {
5274 CmdArgs.push_back("-Bstatic");
5275 } else {
5276 if (Args.hasArg(options::OPT_rdynamic))
5277 CmdArgs.push_back("-export-dynamic");
5278 CmdArgs.push_back("--eh-frame-hdr");
5279 if (Args.hasArg(options::OPT_shared)) {
5280 CmdArgs.push_back("-Bshareable");
5281 } else {
5282 CmdArgs.push_back("-dynamic-linker");
5283 CmdArgs.push_back("/libexec/ld.elf_so");
5284 }
5285 }
5286
5287 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5288 // instruct ld in the base system to link 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005289 if (getToolChain().getArch() == llvm::Triple::x86) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005290 CmdArgs.push_back("-m");
5291 CmdArgs.push_back("elf_i386");
5292 }
5293
5294 if (Output.isFilename()) {
5295 CmdArgs.push_back("-o");
5296 CmdArgs.push_back(Output.getFilename());
5297 } else {
5298 assert(Output.isNothing() && "Invalid output.");
5299 }
5300
5301 if (!Args.hasArg(options::OPT_nostdlib) &&
5302 !Args.hasArg(options::OPT_nostartfiles)) {
5303 if (!Args.hasArg(options::OPT_shared)) {
5304 CmdArgs.push_back(Args.MakeArgString(
5305 getToolChain().GetFilePath("crt0.o")));
5306 CmdArgs.push_back(Args.MakeArgString(
5307 getToolChain().GetFilePath("crti.o")));
5308 CmdArgs.push_back(Args.MakeArgString(
5309 getToolChain().GetFilePath("crtbegin.o")));
5310 } else {
5311 CmdArgs.push_back(Args.MakeArgString(
5312 getToolChain().GetFilePath("crti.o")));
5313 CmdArgs.push_back(Args.MakeArgString(
5314 getToolChain().GetFilePath("crtbeginS.o")));
5315 }
5316 }
5317
5318 Args.AddAllArgs(CmdArgs, options::OPT_L);
5319 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5320 Args.AddAllArgs(CmdArgs, options::OPT_e);
5321 Args.AddAllArgs(CmdArgs, options::OPT_s);
5322 Args.AddAllArgs(CmdArgs, options::OPT_t);
5323 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5324 Args.AddAllArgs(CmdArgs, options::OPT_r);
5325
5326 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5327
5328 if (!Args.hasArg(options::OPT_nostdlib) &&
5329 !Args.hasArg(options::OPT_nodefaultlibs)) {
5330 if (D.CCCIsCXX) {
5331 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5332 CmdArgs.push_back("-lm");
5333 }
5334 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5335 // the default system libraries. Just mimic this for now.
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005336 if (Args.hasArg(options::OPT_static)) {
5337 CmdArgs.push_back("-lgcc_eh");
5338 } else {
5339 CmdArgs.push_back("--as-needed");
5340 CmdArgs.push_back("-lgcc_s");
5341 CmdArgs.push_back("--no-as-needed");
5342 }
Joerg Sonnenberger87717772011-06-07 23:39:17 +00005343 CmdArgs.push_back("-lgcc");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005344
5345 if (Args.hasArg(options::OPT_pthread))
5346 CmdArgs.push_back("-lpthread");
5347 CmdArgs.push_back("-lc");
5348
5349 CmdArgs.push_back("-lgcc");
5350 if (Args.hasArg(options::OPT_static)) {
5351 CmdArgs.push_back("-lgcc_eh");
5352 } else {
5353 CmdArgs.push_back("--as-needed");
5354 CmdArgs.push_back("-lgcc_s");
5355 CmdArgs.push_back("--no-as-needed");
5356 }
5357 }
5358
5359 if (!Args.hasArg(options::OPT_nostdlib) &&
5360 !Args.hasArg(options::OPT_nostartfiles)) {
5361 if (!Args.hasArg(options::OPT_shared))
5362 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5363 "crtend.o")));
5364 else
5365 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5366 "crtendS.o")));
5367 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5368 "crtn.o")));
5369 }
5370
Bill Wendling08760582011-06-27 19:15:03 +00005371 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005372
David Chisnallddbd68f2011-09-27 22:03:18 +00005373 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005374 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5375}
5376
Rafael Espindola92b00932010-08-10 00:25:48 +00005377void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5378 const InputInfo &Output,
5379 const InputInfoList &Inputs,
5380 const ArgList &Args,
5381 const char *LinkingOutput) const {
5382 ArgStringList CmdArgs;
5383
5384 // Add --32/--64 to make sure we get the format we want.
5385 // This is incomplete
5386 if (getToolChain().getArch() == llvm::Triple::x86) {
5387 CmdArgs.push_back("--32");
5388 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5389 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00005390 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5391 CmdArgs.push_back("-a32");
5392 CmdArgs.push_back("-mppc");
5393 CmdArgs.push_back("-many");
5394 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5395 CmdArgs.push_back("-a64");
5396 CmdArgs.push_back("-mppc64");
5397 CmdArgs.push_back("-many");
Rafael Espindola92b00932010-08-10 00:25:48 +00005398 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005399 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00005400 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5401 CmdArgs.push_back("-mfpu=neon");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00005402
5403 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5404 getToolChain().getTriple());
5405 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00005406
5407 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5408 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5409 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005410 } else if (getToolChain().getArch() == llvm::Triple::mips ||
5411 getToolChain().getArch() == llvm::Triple::mipsel ||
5412 getToolChain().getArch() == llvm::Triple::mips64 ||
5413 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005414 StringRef CPUName;
5415 StringRef ABIName;
5416 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005417
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005418 CmdArgs.push_back("-march");
5419 CmdArgs.push_back(CPUName.data());
5420
5421 // Convert ABI name to the GNU tools acceptable variant.
5422 if (ABIName == "o32")
5423 ABIName = "32";
5424 else if (ABIName == "n64")
5425 ABIName = "64";
5426
5427 CmdArgs.push_back("-mabi");
5428 CmdArgs.push_back(ABIName.data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00005429
5430 if (getToolChain().getArch() == llvm::Triple::mips ||
5431 getToolChain().getArch() == llvm::Triple::mips64)
5432 CmdArgs.push_back("-EB");
5433 else
5434 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00005435
5436 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5437 options::OPT_fpic, options::OPT_fno_pic,
5438 options::OPT_fPIE, options::OPT_fno_PIE,
5439 options::OPT_fpie, options::OPT_fno_pie);
5440 if (LastPICArg &&
5441 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5442 LastPICArg->getOption().matches(options::OPT_fpic) ||
5443 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5444 LastPICArg->getOption().matches(options::OPT_fpie))) {
5445 CmdArgs.push_back("-KPIC");
5446 }
Rafael Espindola92b00932010-08-10 00:25:48 +00005447 }
5448
5449 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5450 options::OPT_Xassembler);
5451
5452 CmdArgs.push_back("-o");
5453 CmdArgs.push_back(Output.getFilename());
5454
5455 for (InputInfoList::const_iterator
5456 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5457 const InputInfo &II = *it;
5458 CmdArgs.push_back(II.getFilename());
5459 }
5460
5461 const char *Exec =
5462 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5463 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5464}
5465
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005466static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5467 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00005468 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Logan Chien3d3373c2012-11-19 12:04:11 +00005469 bool StaticLibgcc = Args.hasArg(options::OPT_static) ||
5470 Args.hasArg(options::OPT_static_libgcc);
Rafael Espindolacc354322011-10-17 21:39:04 +00005471 if (!D.CCCIsCXX)
5472 CmdArgs.push_back("-lgcc");
5473
Logan Chien3d3373c2012-11-19 12:04:11 +00005474 if (StaticLibgcc || isAndroid) {
Rafael Espindolacc354322011-10-17 21:39:04 +00005475 if (D.CCCIsCXX)
5476 CmdArgs.push_back("-lgcc");
5477 } else {
5478 if (!D.CCCIsCXX)
5479 CmdArgs.push_back("--as-needed");
5480 CmdArgs.push_back("-lgcc_s");
5481 if (!D.CCCIsCXX)
5482 CmdArgs.push_back("--no-as-needed");
5483 }
5484
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005485 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00005486 CmdArgs.push_back("-lgcc_eh");
5487 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
5488 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00005489
5490 // According to Android ABI, we have to link with libdl if we are
5491 // linking with non-static libgcc.
5492 //
5493 // NOTE: This fixes a link error on Android MIPS as well. The non-static
5494 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
5495 if (isAndroid && !StaticLibgcc)
5496 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00005497}
5498
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005499static bool hasMipsN32ABIArg(const ArgList &Args) {
5500 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
Richard Smithbd55daf2012-11-01 04:30:05 +00005501 return A && (A->getValue() == StringRef("n32"));
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005502}
5503
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005504void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
5505 const InputInfo &Output,
5506 const InputInfoList &Inputs,
5507 const ArgList &Args,
5508 const char *LinkingOutput) const {
5509 const toolchains::Linux& ToolChain =
5510 static_cast<const toolchains::Linux&>(getToolChain());
5511 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00005512 const bool isAndroid =
5513 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005514
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005515 ArgStringList CmdArgs;
5516
Rafael Espindolad1002f62010-11-15 18:28:16 +00005517 // Silence warning for "clang -g foo.o -o foo"
5518 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005519 // and "clang -emit-llvm foo.o -o foo"
5520 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00005521 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00005522 // handled somewhere else.
5523 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00005524
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005525 if (!D.SysRoot.empty())
5526 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005527
Peter Collingbourne24c67c62013-01-17 20:17:16 +00005528 if (Args.hasArg(options::OPT_pie) && !Args.hasArg(options::OPT_shared))
Rafael Espindolad47ac232010-11-17 22:26:15 +00005529 CmdArgs.push_back("-pie");
5530
Rafael Espindola1c76c592010-11-07 22:57:16 +00005531 if (Args.hasArg(options::OPT_rdynamic))
5532 CmdArgs.push_back("-export-dynamic");
5533
Rafael Espindola34d77dc2010-11-11 19:34:42 +00005534 if (Args.hasArg(options::OPT_s))
5535 CmdArgs.push_back("-s");
5536
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005537 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
5538 e = ToolChain.ExtraOpts.end();
5539 i != e; ++i)
5540 CmdArgs.push_back(i->c_str());
5541
5542 if (!Args.hasArg(options::OPT_static)) {
5543 CmdArgs.push_back("--eh-frame-hdr");
5544 }
5545
5546 CmdArgs.push_back("-m");
5547 if (ToolChain.getArch() == llvm::Triple::x86)
5548 CmdArgs.push_back("elf_i386");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005549 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00005550 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005551 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005552 else if (ToolChain.getArch() == llvm::Triple::ppc)
5553 CmdArgs.push_back("elf32ppclinux");
5554 else if (ToolChain.getArch() == llvm::Triple::ppc64)
5555 CmdArgs.push_back("elf64ppc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005556 else if (ToolChain.getArch() == llvm::Triple::mips)
5557 CmdArgs.push_back("elf32btsmip");
5558 else if (ToolChain.getArch() == llvm::Triple::mipsel)
5559 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005560 else if (ToolChain.getArch() == llvm::Triple::mips64) {
5561 if (hasMipsN32ABIArg(Args))
5562 CmdArgs.push_back("elf32btsmipn32");
5563 else
5564 CmdArgs.push_back("elf64btsmip");
5565 }
5566 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
5567 if (hasMipsN32ABIArg(Args))
5568 CmdArgs.push_back("elf32ltsmipn32");
5569 else
5570 CmdArgs.push_back("elf64ltsmip");
5571 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005572 else
5573 CmdArgs.push_back("elf_x86_64");
5574
5575 if (Args.hasArg(options::OPT_static)) {
Douglas Gregord9bb1522011-03-06 19:11:49 +00005576 if (ToolChain.getArch() == llvm::Triple::arm
5577 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005578 CmdArgs.push_back("-Bstatic");
5579 else
5580 CmdArgs.push_back("-static");
5581 } else if (Args.hasArg(options::OPT_shared)) {
5582 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00005583 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005584 CmdArgs.push_back("-Bsymbolic");
5585 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005586 }
5587
5588 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00005589 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005590 (!Args.hasArg(options::OPT_static) &&
5591 !Args.hasArg(options::OPT_shared))) {
5592 CmdArgs.push_back("-dynamic-linker");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005593 if (isAndroid)
5594 CmdArgs.push_back("/system/bin/linker");
5595 else if (ToolChain.getArch() == llvm::Triple::x86)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005596 CmdArgs.push_back("/lib/ld-linux.so.2");
Douglas Gregord9bb1522011-03-06 19:11:49 +00005597 else if (ToolChain.getArch() == llvm::Triple::arm ||
Jiangning Liueabbf922012-07-30 11:05:56 +00005598 ToolChain.getArch() == llvm::Triple::thumb) {
5599 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
5600 CmdArgs.push_back("/lib/ld-linux-armhf.so.3");
5601 else
5602 CmdArgs.push_back("/lib/ld-linux.so.3");
5603 }
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005604 else if (ToolChain.getArch() == llvm::Triple::mips ||
5605 ToolChain.getArch() == llvm::Triple::mipsel)
5606 CmdArgs.push_back("/lib/ld.so.1");
Simon Atanasyan1e1e2e22012-04-06 20:14:27 +00005607 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005608 ToolChain.getArch() == llvm::Triple::mips64el) {
5609 if (hasMipsN32ABIArg(Args))
5610 CmdArgs.push_back("/lib32/ld.so.1");
5611 else
5612 CmdArgs.push_back("/lib64/ld.so.1");
5613 }
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005614 else if (ToolChain.getArch() == llvm::Triple::ppc)
Chris Lattner20b90d02011-04-11 21:15:37 +00005615 CmdArgs.push_back("/lib/ld.so.1");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005616 else if (ToolChain.getArch() == llvm::Triple::ppc64)
Chris Lattner20b90d02011-04-11 21:15:37 +00005617 CmdArgs.push_back("/lib64/ld64.so.1");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005618 else
5619 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
5620 }
5621
5622 CmdArgs.push_back("-o");
5623 CmdArgs.push_back(Output.getFilename());
5624
Rafael Espindola81937ec2010-12-01 01:52:43 +00005625 if (!Args.hasArg(options::OPT_nostdlib) &&
5626 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005627 if (!isAndroid) {
5628 const char *crt1 = NULL;
5629 if (!Args.hasArg(options::OPT_shared)){
5630 if (Args.hasArg(options::OPT_pie))
5631 crt1 = "Scrt1.o";
5632 else
5633 crt1 = "crt1.o";
5634 }
5635 if (crt1)
5636 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005637
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005638 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5639 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005640
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005641 const char *crtbegin;
5642 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005643 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005644 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005645 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005646 else if (Args.hasArg(options::OPT_pie))
5647 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005648 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005649 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005650 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00005651
5652 // Add crtfastmath.o if available and fast math is enabled.
5653 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005654 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005655
5656 Args.AddAllArgs(CmdArgs, options::OPT_L);
5657
5658 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5659
Roman Divackyee8188a2011-03-01 17:53:14 +00005660 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5661 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005662 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005663
Rafael Espindola9446d762012-04-09 23:53:34 +00005664 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5665 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5666 // forward.
5667 if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) {
5668 CmdArgs.push_back("-plugin");
5669 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5670 CmdArgs.push_back(Args.MakeArgString(Plugin));
Chandler Carruth953fb082013-01-13 11:46:33 +00005671
5672 // Try to pass driver level flags relevant to LTO code generation down to
5673 // the plugin.
5674
5675 // Handle architecture-specific flags for selecting CPU variants.
5676 if (ToolChain.getArch() == llvm::Triple::x86 ||
5677 ToolChain.getArch() == llvm::Triple::x86_64)
5678 CmdArgs.push_back(
5679 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5680 getX86TargetCPU(Args, ToolChain.getTriple())));
5681 else if (ToolChain.getArch() == llvm::Triple::arm ||
5682 ToolChain.getArch() == llvm::Triple::thumb)
5683 CmdArgs.push_back(
5684 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5685 getARMTargetCPU(Args, ToolChain.getTriple())));
5686
5687 // FIXME: Factor out logic for MIPS, PPC, and other targets to support this
5688 // as well.
Rafael Espindola9446d762012-04-09 23:53:34 +00005689 }
5690
Chandler Carruth953fb082013-01-13 11:46:33 +00005691
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00005692 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5693 CmdArgs.push_back("--no-demangle");
5694
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005695 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5696
Alexey Samsonov627b10f2012-11-06 15:09:03 +00005697 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00005698
Eric Christopher04997782012-11-29 18:51:05 +00005699 // Call these before we add the C++ ABI library.
Richard Smith52be6192012-11-05 22:04:41 +00005700 if (Sanitize.needsUbsanRt())
5701 addUbsanRTLinux(getToolChain(), Args, CmdArgs);
Eric Christopher04997782012-11-29 18:51:05 +00005702 if (Sanitize.needsAsanRt())
5703 addAsanRTLinux(getToolChain(), Args, CmdArgs);
5704 if (Sanitize.needsTsanRt())
5705 addTsanRTLinux(getToolChain(), Args, CmdArgs);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00005706 if (Sanitize.needsMsanRt())
5707 addMsanRTLinux(getToolChain(), Args, CmdArgs);
Richard Smith4d3110a2012-10-25 02:14:12 +00005708
Chandler Carruth94a32012012-05-14 18:31:18 +00005709 if (D.CCCIsCXX &&
5710 !Args.hasArg(options::OPT_nostdlib) &&
5711 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00005712 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
5713 !Args.hasArg(options::OPT_static);
5714 if (OnlyLibstdcxxStatic)
5715 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005716 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00005717 if (OnlyLibstdcxxStatic)
5718 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005719 CmdArgs.push_back("-lm");
5720 }
5721
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005722 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00005723 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
5724 if (Args.hasArg(options::OPT_static))
5725 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00005726
Chandler Carruth01538002013-01-17 13:19:29 +00005727 bool OpenMP = Args.hasArg(options::OPT_fopenmp);
5728 if (OpenMP) {
5729 CmdArgs.push_back("-lgomp");
5730
5731 // FIXME: Exclude this for platforms whith libgomp that doesn't require
5732 // librt. Most modern Linux platfroms require it, but some may not.
5733 CmdArgs.push_back("-lrt");
5734 }
5735
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005736 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005737
Chandler Carruth94a32012012-05-14 18:31:18 +00005738 if (Args.hasArg(options::OPT_pthread) ||
Chandler Carruth01538002013-01-17 13:19:29 +00005739 Args.hasArg(options::OPT_pthreads) || OpenMP)
Chandler Carruth94a32012012-05-14 18:31:18 +00005740 CmdArgs.push_back("-lpthread");
5741
5742 CmdArgs.push_back("-lc");
5743
5744 if (Args.hasArg(options::OPT_static))
5745 CmdArgs.push_back("--end-group");
5746 else
5747 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5748 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00005749
Rafael Espindola81937ec2010-12-01 01:52:43 +00005750 if (!Args.hasArg(options::OPT_nostartfiles)) {
5751 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005752 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005753 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005754 else if (Args.hasArg(options::OPT_pie))
5755 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00005756 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005757 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005758
Rafael Espindola81937ec2010-12-01 01:52:43 +00005759 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005760 if (!isAndroid)
5761 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00005762 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005763 }
5764
Bill Wendling08760582011-06-27 19:15:03 +00005765 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005766
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005767 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
5768}
Rafael Espindola92b00932010-08-10 00:25:48 +00005769
Chris Lattner3e2ee142010-07-07 16:01:42 +00005770void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005771 const InputInfo &Output,
5772 const InputInfoList &Inputs,
5773 const ArgList &Args,
5774 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005775 ArgStringList CmdArgs;
5776
5777 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5778 options::OPT_Xassembler);
5779
5780 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005781 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00005782
5783 for (InputInfoList::const_iterator
5784 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5785 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005786 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00005787 }
5788
5789 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00005790 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005791 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005792}
5793
5794void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005795 const InputInfo &Output,
5796 const InputInfoList &Inputs,
5797 const ArgList &Args,
5798 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005799 const Driver &D = getToolChain().getDriver();
5800 ArgStringList CmdArgs;
5801
Daniel Dunbarb440f562010-08-02 02:38:21 +00005802 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005803 CmdArgs.push_back("-o");
5804 CmdArgs.push_back(Output.getFilename());
5805 } else {
5806 assert(Output.isNothing() && "Invalid output.");
5807 }
5808
5809 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00005810 !Args.hasArg(options::OPT_nostartfiles)) {
5811 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
5812 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5813 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
5814 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
5815 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005816
5817 Args.AddAllArgs(CmdArgs, options::OPT_L);
5818 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5819 Args.AddAllArgs(CmdArgs, options::OPT_e);
5820
Daniel Dunbar54423b22010-09-17 00:24:54 +00005821 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00005822
Eli Friedman83de5132011-12-08 23:54:21 +00005823 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5824
Chris Lattner3e2ee142010-07-07 16:01:42 +00005825 if (!Args.hasArg(options::OPT_nostdlib) &&
5826 !Args.hasArg(options::OPT_nodefaultlibs)) {
5827 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005828 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00005829 CmdArgs.push_back("-lm");
5830 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005831 }
5832
5833 if (!Args.hasArg(options::OPT_nostdlib) &&
5834 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00005835 if (Args.hasArg(options::OPT_pthread))
5836 CmdArgs.push_back("-lpthread");
5837 CmdArgs.push_back("-lc");
5838 CmdArgs.push_back("-lCompilerRT-Generic");
5839 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
5840 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00005841 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005842 }
5843
Eli Friedman83de5132011-12-08 23:54:21 +00005844 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005845 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005846}
5847
Daniel Dunbarcc912342009-05-02 18:28:39 +00005848/// DragonFly Tools
5849
5850// For now, DragonFly Assemble does just about the same as for
5851// FreeBSD, but this may change soon.
5852void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005853 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005854 const InputInfoList &Inputs,
5855 const ArgList &Args,
5856 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005857 ArgStringList CmdArgs;
5858
5859 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5860 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005861 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00005862 CmdArgs.push_back("--32");
5863
5864 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5865 options::OPT_Xassembler);
5866
5867 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005868 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00005869
5870 for (InputInfoList::const_iterator
5871 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5872 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005873 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00005874 }
5875
5876 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005877 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005878 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005879}
5880
5881void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005882 const InputInfo &Output,
5883 const InputInfoList &Inputs,
5884 const ArgList &Args,
5885 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005886 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00005887 ArgStringList CmdArgs;
5888
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005889 if (!D.SysRoot.empty())
5890 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5891
Daniel Dunbarcc912342009-05-02 18:28:39 +00005892 if (Args.hasArg(options::OPT_static)) {
5893 CmdArgs.push_back("-Bstatic");
5894 } else {
5895 if (Args.hasArg(options::OPT_shared))
5896 CmdArgs.push_back("-Bshareable");
5897 else {
5898 CmdArgs.push_back("-dynamic-linker");
5899 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
5900 }
5901 }
5902
5903 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5904 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005905 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005906 CmdArgs.push_back("-m");
5907 CmdArgs.push_back("elf_i386");
5908 }
5909
Daniel Dunbarb440f562010-08-02 02:38:21 +00005910 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005911 CmdArgs.push_back("-o");
5912 CmdArgs.push_back(Output.getFilename());
5913 } else {
5914 assert(Output.isNothing() && "Invalid output.");
5915 }
5916
5917 if (!Args.hasArg(options::OPT_nostdlib) &&
5918 !Args.hasArg(options::OPT_nostartfiles)) {
5919 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005920 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005921 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005922 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005923 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005924 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005925 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005926 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005927 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005928 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005929 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005930 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005931 }
5932 }
5933
5934 Args.AddAllArgs(CmdArgs, options::OPT_L);
5935 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5936 Args.AddAllArgs(CmdArgs, options::OPT_e);
5937
Daniel Dunbar54423b22010-09-17 00:24:54 +00005938 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00005939
5940 if (!Args.hasArg(options::OPT_nostdlib) &&
5941 !Args.hasArg(options::OPT_nodefaultlibs)) {
5942 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
5943 // rpaths
5944 CmdArgs.push_back("-L/usr/lib/gcc41");
5945
5946 if (!Args.hasArg(options::OPT_static)) {
5947 CmdArgs.push_back("-rpath");
5948 CmdArgs.push_back("/usr/lib/gcc41");
5949
5950 CmdArgs.push_back("-rpath-link");
5951 CmdArgs.push_back("/usr/lib/gcc41");
5952
5953 CmdArgs.push_back("-rpath");
5954 CmdArgs.push_back("/usr/lib");
5955
5956 CmdArgs.push_back("-rpath-link");
5957 CmdArgs.push_back("/usr/lib");
5958 }
5959
Rafael Espindola38360b32010-07-20 12:59:03 +00005960 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005961 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00005962 CmdArgs.push_back("-lm");
5963 }
5964
Daniel Dunbarcc912342009-05-02 18:28:39 +00005965 if (Args.hasArg(options::OPT_shared)) {
5966 CmdArgs.push_back("-lgcc_pic");
5967 } else {
5968 CmdArgs.push_back("-lgcc");
5969 }
5970
5971
5972 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00005973 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00005974
5975 if (!Args.hasArg(options::OPT_nolibc)) {
5976 CmdArgs.push_back("-lc");
5977 }
5978
5979 if (Args.hasArg(options::OPT_shared)) {
5980 CmdArgs.push_back("-lgcc_pic");
5981 } else {
5982 CmdArgs.push_back("-lgcc");
5983 }
5984 }
5985
5986 if (!Args.hasArg(options::OPT_nostdlib) &&
5987 !Args.hasArg(options::OPT_nostartfiles)) {
5988 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005989 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005990 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005991 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005992 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005993 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005994 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005995 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005996 }
5997
Bill Wendling08760582011-06-27 19:15:03 +00005998 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005999
Daniel Dunbarcc912342009-05-02 18:28:39 +00006000 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006001 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006002 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006003}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006004
6005void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6006 const InputInfo &Output,
6007 const InputInfoList &Inputs,
6008 const ArgList &Args,
6009 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006010 ArgStringList CmdArgs;
6011
6012 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00006013 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6014 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006015 } else {
6016 assert(Output.isNothing() && "Invalid output.");
6017 }
6018
6019 if (!Args.hasArg(options::OPT_nostdlib) &&
6020 !Args.hasArg(options::OPT_nostartfiles)) {
6021 CmdArgs.push_back("-defaultlib:libcmt");
6022 }
6023
6024 CmdArgs.push_back("-nologo");
6025
Michael J. Spencere2f49362012-06-18 16:56:04 +00006026 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6027
6028 // Add filenames immediately.
6029 for (InputInfoList::const_iterator
6030 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6031 if (it->isFilename())
6032 CmdArgs.push_back(it->getFilename());
6033 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006034
6035 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00006036 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006037 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6038}