blob: 77c7d2270b1d6bd5cf0c15b0ebdc4fbdb6643329 [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,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000231 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000232 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000233 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000234 ArgStringList &CmdArgs,
235 const InputInfo &Output,
236 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000237 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000238
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000239 CheckPreprocessingOptions(D, Args);
240
241 Args.AddLastArg(CmdArgs, options::OPT_C);
242 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000243
244 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000245 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000246 (A = Args.getLastArg(options::OPT_MD)) ||
247 (A = Args.getLastArg(options::OPT_MMD))) {
248 // Determine the output location.
249 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000250 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000251 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000252 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000253 } else if (Output.getType() == types::TY_Dependencies) {
254 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000255 } else if (A->getOption().matches(options::OPT_M) ||
256 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000257 DepFile = "-";
258 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000259 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000260 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000261 }
262 CmdArgs.push_back("-dependency-file");
263 CmdArgs.push_back(DepFile);
264
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000265 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000266 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
267 const char *DepTarget;
268
269 // If user provided -o, that is the dependency target, except
270 // when we are only generating a dependency file.
271 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
272 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000273 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000274 } else {
275 // Otherwise derive from the base input.
276 //
277 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000278 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000279 llvm::sys::path::replace_extension(P, "o");
280 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000281 }
282
283 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000284 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000285 QuoteTarget(DepTarget, Quoted);
286 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000287 }
288
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000289 if (A->getOption().matches(options::OPT_M) ||
290 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000291 CmdArgs.push_back("-sys-header-deps");
292 }
293
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000294 if (Args.hasArg(options::OPT_MG)) {
295 if (!A || A->getOption().matches(options::OPT_MD) ||
296 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000297 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000298 CmdArgs.push_back("-MG");
299 }
300
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000301 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000302
303 // Convert all -MQ <target> args to -MT <quoted target>
304 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
305 options::OPT_MQ),
306 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000307 const Arg *A = *it;
308 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000309
Daniel Dunbara442fd52010-06-11 22:00:13 +0000310 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000311 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000312 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000313 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000314 CmdArgs.push_back(Args.MakeArgString(Quoted));
315
316 // -MT flag - no change
317 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000318 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000319 }
320 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000321
Douglas Gregor111af7d2009-04-18 00:34:01 +0000322 // Add -i* options, and automatically translate to
323 // -include-pch/-include-pth for transparent PCH support. It's
324 // wonky, but we include looking for .gch so we can support seamless
325 // replacement into a build system already set up to be generating
326 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000327 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000328 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
329 ie = Args.filtered_end(); it != ie; ++it) {
330 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000331
332 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000333 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
334 RenderedImplicitInclude = true;
335
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000336 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000337 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000338
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000339 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000340 bool FoundPCH = false;
Richard Smithbd55daf2012-11-01 04:30:05 +0000341 llvm::sys::Path P(A->getValue());
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000342 bool Exists;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000343 if (UsePCH) {
Douglas Gregor111af7d2009-04-18 00:34:01 +0000344 P.appendSuffix("pch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000345 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000346 FoundPCH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000347 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000348 P.eraseSuffix();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000349 }
350
Douglas Gregor111af7d2009-04-18 00:34:01 +0000351 if (!FoundPCH) {
352 P.appendSuffix("pth");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000353 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000354 FoundPTH = true;
355 else
356 P.eraseSuffix();
Mike Stump11289f42009-09-09 15:08:12 +0000357 }
358
Douglas Gregor111af7d2009-04-18 00:34:01 +0000359 if (!FoundPCH && !FoundPTH) {
360 P.appendSuffix("gch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000361 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000362 FoundPCH = UsePCH;
363 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000364 }
Mike Stump11289f42009-09-09 15:08:12 +0000365 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000366 P.eraseSuffix();
367 }
368
369 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000370 if (IsFirstImplicitInclude) {
371 A->claim();
372 if (UsePCH)
373 CmdArgs.push_back("-include-pch");
374 else
375 CmdArgs.push_back("-include-pth");
376 CmdArgs.push_back(Args.MakeArgString(P.str()));
377 continue;
378 } else {
379 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000380 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000381 << P.str() << A->getAsString(Args);
382 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000383 }
384 }
385
386 // Not translated, render as usual.
387 A->claim();
388 A->render(Args, CmdArgs);
389 }
390
391 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000392 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
393 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000394
395 // Add -Wp, and -Xassembler if using the preprocessor.
396
397 // FIXME: There is a very unfortunate problem here, some troubled
398 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
399 // really support that we would have to parse and then translate
400 // those options. :(
401 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
402 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000403
404 // -I- is a deprecated GCC feature, reject it.
405 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000406 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000407
408 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
409 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000410 StringRef sysroot = C.getSysRoot();
411 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000412 if (!Args.hasArg(options::OPT_isysroot)) {
413 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000414 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000415 }
416 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000417
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000418 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000419 // FIXME: We should probably sink the logic for handling these from the
420 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000421 // CPATH - included following the user specified includes (but prior to
422 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000423 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000424 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000425 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000426 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000427 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000428 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000429 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000430 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000431 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000432
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000433 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000434 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000435 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000436
437 // Add system include arguments.
438 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000439}
440
Daniel Dunbarf492c922009-09-10 22:59:51 +0000441/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000442/// CPU.
443//
444// FIXME: This is redundant with -mcpu, why does LLVM use this.
445// FIXME: tblgen this, or kill it!
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000446static const char *getLLVMArchSuffixForARM(StringRef CPU) {
Chad Rosier9ac84512011-10-07 17:48:56 +0000447 return llvm::StringSwitch<const char *>(CPU)
448 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
449 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
450 .Cases("arm920", "arm920t", "arm922t", "v4t")
451 .Cases("arm940t", "ep9312","v4t")
452 .Cases("arm10tdmi", "arm1020t", "v5")
453 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
454 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
455 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
456 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
457 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
458 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Quentin Colombet2e9952e2012-11-29 23:15:27 +0000459 .Cases("cortex-a5", "cortex-a8", "cortex-a9", "cortex-a15", "v7")
Quentin Colombetf5a37a32012-12-21 17:57:47 +0000460 .Case("cortex-r5", "v7r")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000461 .Case("cortex-m3", "v7m")
Jim Grosbach903e63f2012-03-29 19:53:34 +0000462 .Case("cortex-m4", "v7m")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000463 .Case("cortex-m0", "v6m")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000464 .Case("cortex-a9-mp", "v7f")
465 .Case("swift", "v7s")
Chad Rosier9ac84512011-10-07 17:48:56 +0000466 .Default("");
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000467}
468
Benjamin Kramer09811c72012-06-26 22:20:06 +0000469/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
470//
471// FIXME: tblgen this.
472static std::string getARMTargetCPU(const ArgList &Args,
473 const llvm::Triple &Triple) {
474 // FIXME: Warn on inconsistent use of -mcpu and -march.
475
476 // If we have -mcpu=, use that.
477 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000478 StringRef MCPU = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000479 // Handle -mcpu=native.
480 if (MCPU == "native")
481 return llvm::sys::getHostCPUName();
482 else
483 return MCPU;
484 }
485
486 StringRef MArch;
487 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
488 // Otherwise, if we have -march= choose the base CPU for that arch.
Richard Smithbd55daf2012-11-01 04:30:05 +0000489 MArch = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000490 } else {
491 // Otherwise, use the Arch from the triple.
492 MArch = Triple.getArchName();
493 }
494
495 // Handle -march=native.
496 std::string NativeMArch;
497 if (MArch == "native") {
498 std::string CPU = llvm::sys::getHostCPUName();
499 if (CPU != "generic") {
500 // Translate the native cpu into the architecture. The switch below will
501 // then chose the minimum cpu for that arch.
502 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
503 MArch = NativeMArch;
504 }
505 }
506
507 return llvm::StringSwitch<const char *>(MArch)
508 .Cases("armv2", "armv2a","arm2")
509 .Case("armv3", "arm6")
510 .Case("armv3m", "arm7m")
511 .Cases("armv4", "armv4t", "arm7tdmi")
512 .Cases("armv5", "armv5t", "arm10tdmi")
513 .Cases("armv5e", "armv5te", "arm1022e")
514 .Case("armv5tej", "arm926ej-s")
515 .Cases("armv6", "armv6k", "arm1136jf-s")
516 .Case("armv6j", "arm1136j-s")
517 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
518 .Case("armv6t2", "arm1156t2-s")
519 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000520 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
521 .Cases("armv7s", "armv7-s", "swift")
Benjamin Kramer09811c72012-06-26 22:20:06 +0000522 .Cases("armv7r", "armv7-r", "cortex-r4")
523 .Cases("armv7m", "armv7-m", "cortex-m3")
524 .Case("ep9312", "ep9312")
525 .Case("iwmmxt", "iwmmxt")
526 .Case("xscale", "xscale")
527 .Cases("armv6m", "armv6-m", "cortex-m0")
528 // If all else failed, return the most base CPU LLVM supports.
529 .Default("arm7tdmi");
530}
531
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000532// FIXME: Move to target hook.
533static bool isSignedCharDefault(const llvm::Triple &Triple) {
534 switch (Triple.getArch()) {
535 default:
536 return true;
537
Tim Northover9bb857a2013-01-31 12:13:10 +0000538 case llvm::Triple::aarch64:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000539 case llvm::Triple::arm:
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000540 case llvm::Triple::ppc:
541 case llvm::Triple::ppc64:
Bob Wilson6524dd32011-10-14 05:03:44 +0000542 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000543 return true;
544 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000545 }
546}
547
Chad Rosiercfbfc582012-04-04 20:51:35 +0000548// Handle -mfpu=.
549//
550// FIXME: Centralize feature selection, defaulting shouldn't be also in the
551// frontend target.
552static void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args,
553 ArgStringList &CmdArgs) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000554 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000555
556 // Set the target features based on the FPU.
557 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
558 // Disable any default FPU support.
559 CmdArgs.push_back("-target-feature");
560 CmdArgs.push_back("-vfp2");
561 CmdArgs.push_back("-target-feature");
562 CmdArgs.push_back("-vfp3");
563 CmdArgs.push_back("-target-feature");
564 CmdArgs.push_back("-neon");
565 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
566 CmdArgs.push_back("-target-feature");
567 CmdArgs.push_back("+vfp3");
568 CmdArgs.push_back("-target-feature");
569 CmdArgs.push_back("+d16");
570 CmdArgs.push_back("-target-feature");
571 CmdArgs.push_back("-neon");
572 } else if (FPU == "vfp") {
573 CmdArgs.push_back("-target-feature");
574 CmdArgs.push_back("+vfp2");
575 CmdArgs.push_back("-target-feature");
576 CmdArgs.push_back("-neon");
577 } else if (FPU == "vfp3" || FPU == "vfpv3") {
578 CmdArgs.push_back("-target-feature");
579 CmdArgs.push_back("+vfp3");
580 CmdArgs.push_back("-target-feature");
581 CmdArgs.push_back("-neon");
582 } else if (FPU == "neon") {
583 CmdArgs.push_back("-target-feature");
584 CmdArgs.push_back("+neon");
585 } else
586 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
587}
588
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000589// Handle -mfpmath=.
590static void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args,
Chad Rosier45619cb2012-04-04 22:13:40 +0000591 ArgStringList &CmdArgs, StringRef CPU) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000592 StringRef FPMath = A->getValue();
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000593
594 // Set the target features based on the FPMath.
595 if (FPMath == "neon") {
596 CmdArgs.push_back("-target-feature");
597 CmdArgs.push_back("+neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000598
Silviu Baranga157f7c62012-09-13 15:06:00 +0000599 if (CPU != "cortex-a8" && CPU != "cortex-a9" && CPU != "cortex-a9-mp" &&
Quentin Colombet2e9952e2012-11-29 23:15:27 +0000600 CPU != "cortex-a15" && CPU != "cortex-a5")
Chad Rosier45619cb2012-04-04 22:13:40 +0000601 D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU;
602
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000603 } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" ||
604 FPMath == "vfp4") {
605 CmdArgs.push_back("-target-feature");
606 CmdArgs.push_back("-neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000607
608 // FIXME: Add warnings when disabling a feature not present for a given CPU.
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000609 } else
610 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
611}
612
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000613// Select the float ABI as determined by -msoft-float, -mhard-float, and
614// -mfloat-abi=.
615static StringRef getARMFloatABI(const Driver &D,
616 const ArgList &Args,
617 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000618 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000619 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
620 options::OPT_mhard_float,
621 options::OPT_mfloat_abi_EQ)) {
622 if (A->getOption().matches(options::OPT_msoft_float))
623 FloatABI = "soft";
624 else if (A->getOption().matches(options::OPT_mhard_float))
625 FloatABI = "hard";
626 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000627 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000628 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000629 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000630 << A->getAsString(Args);
631 FloatABI = "soft";
632 }
633 }
634 }
635
636 // If unspecified, choose the default based on the platform.
637 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000638 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000639 case llvm::Triple::Darwin:
640 case llvm::Triple::MacOSX:
641 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000642 // Darwin defaults to "softfp" for v6 and v7.
643 //
644 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000645 std::string ArchName =
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000646 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000647 if (StringRef(ArchName).startswith("v6") ||
648 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000649 FloatABI = "softfp";
650 else
651 FloatABI = "soft";
652 break;
653 }
654
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000655 case llvm::Triple::FreeBSD:
656 // FreeBSD defaults to soft float
657 FloatABI = "soft";
658 break;
659
Daniel Dunbar78485922009-09-10 23:00:09 +0000660 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000661 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000662 case llvm::Triple::GNUEABIHF:
663 FloatABI = "hard";
664 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000665 case llvm::Triple::GNUEABI:
666 FloatABI = "softfp";
667 break;
668 case llvm::Triple::EABI:
669 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
670 FloatABI = "softfp";
671 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000672 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000673 std::string ArchName =
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000674 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000675 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000676 FloatABI = "softfp";
677 else
678 FloatABI = "soft";
679 break;
680 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000681 default:
682 // Assume "soft", but warn the user we are guessing.
683 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000684 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000685 break;
686 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000687 }
688 }
689
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000690 return FloatABI;
691}
692
693
694void Clang::AddARMTargetArgs(const ArgList &Args,
695 ArgStringList &CmdArgs,
696 bool KernelOrKext) const {
697 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000698 // Get the effective triple, which takes into account the deployment target.
699 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
700 llvm::Triple Triple(TripleStr);
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000701 std::string CPUName = getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000702
703 // Select the ABI to use.
704 //
705 // FIXME: Support -meabi.
706 const char *ABIName = 0;
707 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000708 ABIName = A->getValue();
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000709 } else if (Triple.isOSDarwin()) {
710 // The backend is hardwired to assume AAPCS for M-class processors, ensure
711 // the frontend matches that.
712 if (StringRef(CPUName).startswith("cortex-m")) {
713 ABIName = "aapcs";
714 } else {
715 ABIName = "apcs-gnu";
716 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000717 } else {
718 // Select the default based on the platform.
719 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000720 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000721 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000722 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000723 ABIName = "aapcs-linux";
724 break;
725 case llvm::Triple::EABI:
726 ABIName = "aapcs";
727 break;
728 default:
729 ABIName = "apcs-gnu";
730 }
731 }
732 CmdArgs.push_back("-target-abi");
733 CmdArgs.push_back(ABIName);
734
735 // Set the CPU based on -march= and -mcpu=.
736 CmdArgs.push_back("-target-cpu");
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000737 CmdArgs.push_back(Args.MakeArgString(CPUName));
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000738
739 // Determine floating point ABI from the options & target defaults.
740 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000741 if (FloatABI == "soft") {
742 // Floating point operations and argument passing are soft.
743 //
744 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000745 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000746 CmdArgs.push_back("-mfloat-abi");
747 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000748 } else if (FloatABI == "softfp") {
749 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000750 CmdArgs.push_back("-mfloat-abi");
751 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000752 } else {
753 // Floating point operations and argument passing are hard.
754 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000755 CmdArgs.push_back("-mfloat-abi");
756 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000757 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000758
759 // Set appropriate target features for floating point mode.
760 //
761 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
762 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
763 // stripped out by the ARM target.
764
765 // Use software floating point operations?
766 if (FloatABI == "soft") {
767 CmdArgs.push_back("-target-feature");
768 CmdArgs.push_back("+soft-float");
769 }
770
771 // Use software floating point argument passing?
772 if (FloatABI != "hard") {
773 CmdArgs.push_back("-target-feature");
774 CmdArgs.push_back("+soft-float-abi");
775 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +0000776
777 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +0000778 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +0000779 addFPUArgs(D, A, Args, CmdArgs);
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000780
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000781 // Honor -mfpmath=.
782 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +0000783 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000784
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000785 // Setting -msoft-float effectively disables NEON because of the GCC
786 // implementation, although the same isn't true of VFP or VFP3.
787 if (FloatABI == "soft") {
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000788 CmdArgs.push_back("-target-feature");
789 CmdArgs.push_back("-neon");
790 }
791
792 // Kernel code has more strict alignment requirements.
793 if (KernelOrKext) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000794 if (Triple.getOS() != llvm::Triple::IOS || Triple.isOSVersionLT(6)) {
795 CmdArgs.push_back("-backend-option");
796 CmdArgs.push_back("-arm-long-calls");
797 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000798
Daniel Dunbar12100e22011-03-22 16:48:17 +0000799 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000800 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000801
802 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000803 CmdArgs.push_back("-backend-option");
804 CmdArgs.push_back("-arm-darwin-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000805 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000806
807 // Setting -mno-global-merge disables the codegen global merge pass. Setting
808 // -mglobal-merge has no effect as the pass is enabled by default.
809 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
810 options::OPT_mno_global_merge)) {
811 if (A->getOption().matches(options::OPT_mno_global_merge))
812 CmdArgs.push_back("-mno-global-merge");
813 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000814
Chad Rosierc14ded72012-05-16 21:19:55 +0000815 if (Args.hasArg(options::OPT_mno_implicit_float))
Chad Rosierf1985d22012-05-16 20:40:09 +0000816 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000817}
818
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000819// Translate MIPS CPU name alias option to CPU name.
820static StringRef getMipsCPUFromAlias(const Arg &A) {
821 if (A.getOption().matches(options::OPT_mips32))
822 return "mips32";
823 if (A.getOption().matches(options::OPT_mips32r2))
824 return "mips32r2";
825 if (A.getOption().matches(options::OPT_mips64))
826 return "mips64";
827 if (A.getOption().matches(options::OPT_mips64r2))
828 return "mips64r2";
829 llvm_unreachable("Unexpected option");
830 return "";
831}
832
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000833// Get CPU and ABI names. They are not independent
834// so we have to calculate them together.
835static void getMipsCPUAndABI(const ArgList &Args,
836 const ToolChain &TC,
837 StringRef &CPUName,
838 StringRef &ABIName) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000839 const char *DefMips32CPU = "mips32";
840 const char *DefMips64CPU = "mips64";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000841
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000842 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000843 options::OPT_mcpu_EQ,
844 options::OPT_mips_CPUs_Group)) {
845 if (A->getOption().matches(options::OPT_mips_CPUs_Group))
846 CPUName = getMipsCPUFromAlias(*A);
847 else
Richard Smithbd55daf2012-11-01 04:30:05 +0000848 CPUName = A->getValue();
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000849 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000850
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000851 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000852 ABIName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000853
854 // Setup default CPU and ABI names.
855 if (CPUName.empty() && ABIName.empty()) {
856 switch (TC.getTriple().getArch()) {
857 default:
858 llvm_unreachable("Unexpected triple arch name");
859 case llvm::Triple::mips:
860 case llvm::Triple::mipsel:
861 CPUName = DefMips32CPU;
862 break;
863 case llvm::Triple::mips64:
864 case llvm::Triple::mips64el:
865 CPUName = DefMips64CPU;
866 break;
867 }
868 }
869
870 if (!ABIName.empty()) {
871 // Deduce CPU name from ABI name.
872 CPUName = llvm::StringSwitch<const char *>(ABIName)
873 .Cases("o32", "eabi", DefMips32CPU)
874 .Cases("n32", "n64", DefMips64CPU)
875 .Default("");
876 }
877 else if (!CPUName.empty()) {
878 // Deduce ABI name from CPU name.
879 ABIName = llvm::StringSwitch<const char *>(CPUName)
880 .Cases("mips32", "mips32r2", "o32")
881 .Cases("mips64", "mips64r2", "n64")
882 .Default("");
883 }
884
885 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000886}
887
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000888// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
889// and -mfloat-abi=.
890static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000891 // Select the float ABI as determined by -msoft-float, -mhard-float,
892 // and -mfloat-abi=.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000893 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000894 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000895 options::OPT_mhard_float,
896 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000897 if (A->getOption().matches(options::OPT_msoft_float))
898 FloatABI = "soft";
899 else if (A->getOption().matches(options::OPT_mhard_float))
900 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000901 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000902 FloatABI = A->getValue();
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000903 if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000904 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000905 FloatABI = "hard";
906 }
907 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000908 }
909
910 // If unspecified, choose the default based on the platform.
911 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000912 // Assume "hard", because it's a default value used by gcc.
913 // When we start to recognize specific target MIPS processors,
914 // we will be able to select the default more correctly.
915 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000916 }
917
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000918 return FloatABI;
919}
920
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000921static void AddTargetFeature(const ArgList &Args,
922 ArgStringList &CmdArgs,
923 OptSpecifier OnOpt,
924 OptSpecifier OffOpt,
925 StringRef FeatureName) {
926 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
927 CmdArgs.push_back("-target-feature");
928 if (A->getOption().matches(OnOpt))
929 CmdArgs.push_back(Args.MakeArgString("+" + FeatureName));
930 else
931 CmdArgs.push_back(Args.MakeArgString("-" + FeatureName));
932 }
933}
934
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000935void Clang::AddMIPSTargetArgs(const ArgList &Args,
936 ArgStringList &CmdArgs) const {
937 const Driver &D = getToolChain().getDriver();
938 StringRef CPUName;
939 StringRef ABIName;
940 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
941
942 CmdArgs.push_back("-target-cpu");
943 CmdArgs.push_back(CPUName.data());
944
945 CmdArgs.push_back("-target-abi");
946 CmdArgs.push_back(ABIName.data());
947
948 StringRef FloatABI = getMipsFloatABI(D, Args);
949
Simon Atanasyan81c423c2013-01-10 12:36:19 +0000950 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
951
952 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000953 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +0000954 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000955 CmdArgs.push_back("-mfloat-abi");
956 CmdArgs.push_back("soft");
957
958 // FIXME: Note, this is a hack. We need to pass the selected float
959 // mode to the MipsTargetInfoBase to define appropriate macros there.
960 // Now it is the only method.
961 CmdArgs.push_back("-target-feature");
962 CmdArgs.push_back("+soft-float");
Simon Atanasyan81c423c2013-01-10 12:36:19 +0000963
964 if (FloatABI == "hard" && IsMips16) {
965 CmdArgs.push_back("-mllvm");
966 CmdArgs.push_back("-mips16-hard-float");
967 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000968 }
969 else if (FloatABI == "single") {
970 // Restrict the use of hardware floating-point
971 // instructions to 32-bit operations.
972 CmdArgs.push_back("-target-feature");
973 CmdArgs.push_back("+single-float");
974 }
975 else {
976 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +0000977 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000978 CmdArgs.push_back("-mfloat-abi");
979 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +0000980 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +0000981
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000982 AddTargetFeature(Args, CmdArgs,
983 options::OPT_mips16, options::OPT_mno_mips16,
984 "mips16");
Simon Atanasyan9c6f1f72012-07-05 19:23:00 +0000985 AddTargetFeature(Args, CmdArgs,
986 options::OPT_mdsp, options::OPT_mno_dsp,
987 "dsp");
988 AddTargetFeature(Args, CmdArgs,
989 options::OPT_mdspr2, options::OPT_mno_dspr2,
990 "dspr2");
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000991
Simon Atanasyan2eaec512012-12-01 18:27:21 +0000992 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
993 if (A->getOption().matches(options::OPT_mxgot)) {
994 CmdArgs.push_back("-mllvm");
995 CmdArgs.push_back("-mxgot");
996 }
997 }
998
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000999 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001000 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001001 CmdArgs.push_back("-mllvm");
1002 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1003 A->claim();
1004 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001005}
1006
Hal Finkel8eb59282012-06-11 22:35:19 +00001007/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1008static std::string getPPCTargetCPU(const ArgList &Args) {
1009 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001010 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001011
1012 if (CPUName == "native") {
1013 std::string CPU = llvm::sys::getHostCPUName();
1014 if (!CPU.empty() && CPU != "generic")
1015 return CPU;
1016 else
1017 return "";
1018 }
1019
1020 return llvm::StringSwitch<const char *>(CPUName)
1021 .Case("common", "generic")
1022 .Case("440", "440")
1023 .Case("440fp", "440")
1024 .Case("450", "450")
1025 .Case("601", "601")
1026 .Case("602", "602")
1027 .Case("603", "603")
1028 .Case("603e", "603e")
1029 .Case("603ev", "603ev")
1030 .Case("604", "604")
1031 .Case("604e", "604e")
1032 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001033 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001034 .Case("G3", "g3")
1035 .Case("7400", "7400")
1036 .Case("G4", "g4")
1037 .Case("7450", "7450")
1038 .Case("G4+", "g4+")
1039 .Case("750", "750")
1040 .Case("970", "970")
1041 .Case("G5", "g5")
1042 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001043 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001044 .Case("e500mc", "e500mc")
1045 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001046 .Case("power3", "pwr3")
1047 .Case("power4", "pwr4")
1048 .Case("power5", "pwr5")
1049 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001050 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001051 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001052 .Case("power7", "pwr7")
Bill Schmidt38378a02013-02-01 20:23:10 +00001053 .Case("pwr3", "pwr3")
1054 .Case("pwr4", "pwr4")
1055 .Case("pwr5", "pwr5")
1056 .Case("pwr5x", "pwr5x")
1057 .Case("pwr6", "pwr6")
1058 .Case("pwr6x", "pwr6x")
1059 .Case("pwr7", "pwr7")
Hal Finkel8eb59282012-06-11 22:35:19 +00001060 .Case("powerpc", "ppc")
1061 .Case("powerpc64", "ppc64")
1062 .Default("");
1063 }
1064
1065 return "";
1066}
1067
1068void Clang::AddPPCTargetArgs(const ArgList &Args,
1069 ArgStringList &CmdArgs) const {
1070 std::string TargetCPUName = getPPCTargetCPU(Args);
1071
1072 // LLVM may default to generating code for the native CPU,
1073 // but, like gcc, we default to a more generic option for
1074 // each architecture. (except on Darwin)
1075 llvm::Triple Triple = getToolChain().getTriple();
1076 if (TargetCPUName.empty() && !Triple.isOSDarwin()) {
1077 if (Triple.getArch() == llvm::Triple::ppc64)
1078 TargetCPUName = "ppc64";
1079 else
1080 TargetCPUName = "ppc";
1081 }
1082
1083 if (!TargetCPUName.empty()) {
1084 CmdArgs.push_back("-target-cpu");
1085 CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str()));
1086 }
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001087
1088 // Allow override of the Altivec feature.
1089 if (Args.hasFlag(options::OPT_fno_altivec, options::OPT_faltivec, false)) {
1090 CmdArgs.push_back("-target-feature");
1091 CmdArgs.push_back("-altivec");
1092 }
Hal Finkelb58ce852013-02-01 18:44:19 +00001093
1094 if (Args.hasFlag(options::OPT_mno_qpx, options::OPT_mqpx, false)) {
1095 CmdArgs.push_back("-target-feature");
1096 CmdArgs.push_back("-qpx");
1097 }
Hal Finkel8eb59282012-06-11 22:35:19 +00001098}
1099
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001100void Clang::AddSparcTargetArgs(const ArgList &Args,
1101 ArgStringList &CmdArgs) const {
1102 const Driver &D = getToolChain().getDriver();
1103
1104 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001105 CmdArgs.push_back("-target-cpu");
Richard Smithbd55daf2012-11-01 04:30:05 +00001106 CmdArgs.push_back(A->getValue());
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001107 }
1108
1109 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001110 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001111 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1112 options::OPT_mhard_float)) {
1113 if (A->getOption().matches(options::OPT_msoft_float))
1114 FloatABI = "soft";
1115 else if (A->getOption().matches(options::OPT_mhard_float))
1116 FloatABI = "hard";
1117 }
1118
1119 // If unspecified, choose the default based on the platform.
1120 if (FloatABI.empty()) {
1121 switch (getToolChain().getTriple().getOS()) {
1122 default:
1123 // Assume "soft", but warn the user we are guessing.
1124 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001125 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001126 break;
1127 }
1128 }
1129
1130 if (FloatABI == "soft") {
1131 // Floating point operations and argument passing are soft.
1132 //
1133 // FIXME: This changes CPP defines, we need -target-soft-float.
1134 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001135 CmdArgs.push_back("-target-feature");
1136 CmdArgs.push_back("+soft-float");
1137 } else {
1138 assert(FloatABI == "hard" && "Invalid float abi!");
1139 CmdArgs.push_back("-mhard-float");
1140 }
1141}
1142
Chandler Carruth953fb082013-01-13 11:46:33 +00001143static const char *getX86TargetCPU(const ArgList &Args,
1144 const llvm::Triple &Triple) {
1145 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1146 if (StringRef(A->getValue()) != "native")
1147 return A->getValue();
1148
1149 // FIXME: Reject attempts to use -march=native unless the target matches
1150 // the host.
1151 //
1152 // FIXME: We should also incorporate the detected target features for use
1153 // with -native.
1154 std::string CPU = llvm::sys::getHostCPUName();
1155 if (!CPU.empty() && CPU != "generic")
1156 return Args.MakeArgString(CPU);
1157 }
1158
1159 // Select the default CPU if none was given (or detection failed).
1160
1161 if (Triple.getArch() != llvm::Triple::x86_64 &&
1162 Triple.getArch() != llvm::Triple::x86)
1163 return 0; // This routine is only handling x86 targets.
1164
1165 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1166
1167 // FIXME: Need target hooks.
1168 if (Triple.isOSDarwin())
1169 return Is64Bit ? "core2" : "yonah";
1170
1171 // Everything else goes to x86-64 in 64-bit mode.
1172 if (Is64Bit)
1173 return "x86-64";
1174
1175 if (Triple.getOSName().startswith("haiku"))
1176 return "i586";
1177 if (Triple.getOSName().startswith("openbsd"))
1178 return "i486";
1179 if (Triple.getOSName().startswith("bitrig"))
1180 return "i686";
1181 if (Triple.getOSName().startswith("freebsd"))
1182 return "i486";
1183 if (Triple.getOSName().startswith("netbsd"))
1184 return "i486";
1185 // All x86 devices running Android have core2 as their common
1186 // denominator. This makes a better choice than pentium4.
1187 if (Triple.getEnvironment() == llvm::Triple::Android)
1188 return "core2";
1189
1190 // Fallback to p4.
1191 return "pentium4";
1192}
1193
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001194void Clang::AddX86TargetArgs(const ArgList &Args,
1195 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001196 if (!Args.hasFlag(options::OPT_mred_zone,
1197 options::OPT_mno_red_zone,
1198 true) ||
1199 Args.hasArg(options::OPT_mkernel) ||
1200 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001201 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001202
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001203 if (Args.hasFlag(options::OPT_msoft_float,
1204 options::OPT_mno_soft_float,
1205 false))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001206 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001207
Chandler Carruth953fb082013-01-13 11:46:33 +00001208 if (const char *CPUName = getX86TargetCPU(Args, getToolChain().getTriple())) {
Daniel Dunbara7d02312009-12-18 06:30:12 +00001209 CmdArgs.push_back("-target-cpu");
Daniel Dunbare13ada62009-11-14 22:04:54 +00001210 CmdArgs.push_back(CPUName);
1211 }
1212
Eli Friedmanad811f02011-07-02 00:34:19 +00001213 // The required algorithm here is slightly strange: the options are applied
1214 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
1215 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
1216 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
1217 // former correctly, but not the latter; handle directly-overridden
1218 // attributes here.
1219 llvm::StringMap<unsigned> PrevFeature;
1220 std::vector<const char*> Features;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001221 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1222 ie = Args.filtered_end(); it != ie; ++it) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001223 StringRef Name = (*it)->getOption().getName();
Daniel Dunbara442fd52010-06-11 22:00:13 +00001224 (*it)->claim();
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001225
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001226 // Skip over "-m".
Michael J. Spencer929fccd2012-10-22 22:13:48 +00001227 assert(Name.startswith("m") && "Invalid feature name.");
1228 Name = Name.substr(1);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001229
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001230 bool IsNegative = Name.startswith("no-");
1231 if (IsNegative)
1232 Name = Name.substr(3);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001233
Eli Friedmanad811f02011-07-02 00:34:19 +00001234 unsigned& Prev = PrevFeature[Name];
1235 if (Prev)
1236 Features[Prev - 1] = 0;
1237 Prev = Features.size() + 1;
1238 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1239 }
1240 for (unsigned i = 0; i < Features.size(); i++) {
1241 if (Features[i]) {
1242 CmdArgs.push_back("-target-feature");
1243 CmdArgs.push_back(Features[i]);
1244 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001245 }
1246}
1247
Matthew Curtise8f80a12012-12-06 17:49:03 +00001248static inline bool HasPICArg(const ArgList &Args) {
1249 return Args.hasArg(options::OPT_fPIC)
1250 || Args.hasArg(options::OPT_fpic);
1251}
1252
1253static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1254 return Args.getLastArg(options::OPT_G,
1255 options::OPT_G_EQ,
1256 options::OPT_msmall_data_threshold_EQ);
1257}
1258
1259static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1260 std::string value;
1261 if (HasPICArg(Args))
1262 value = "0";
1263 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1264 value = A->getValue();
1265 A->claim();
1266 }
1267 return value;
1268}
1269
Tony Linthicum76329bf2011-12-12 21:14:55 +00001270void Clang::AddHexagonTargetArgs(const ArgList &Args,
1271 ArgStringList &CmdArgs) const {
1272 llvm::Triple Triple = getToolChain().getTriple();
1273
1274 CmdArgs.push_back("-target-cpu");
Matthew Curtisf10a5952012-12-06 14:16:43 +00001275 CmdArgs.push_back(Args.MakeArgString(
1276 "hexagon"
1277 + toolchains::Hexagon_TC::GetTargetCPU(Args)));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001278 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001279 CmdArgs.push_back("-mqdsp6-compat");
1280 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001281
Matthew Curtise8f80a12012-12-06 17:49:03 +00001282 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1283 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001284 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001285 CmdArgs.push_back(Args.MakeArgString(
1286 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001287 }
1288
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001289 if (!Args.hasArg(options::OPT_fno_short_enums))
1290 CmdArgs.push_back("-fshort-enums");
1291 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1292 CmdArgs.push_back ("-mllvm");
1293 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1294 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001295 CmdArgs.push_back ("-mllvm");
1296 CmdArgs.push_back ("-machine-sink-split=0");
1297}
1298
Eric Christopher84fbdb42011-08-19 00:30:14 +00001299static bool
John McCall5fb5df92012-06-20 06:18:46 +00001300shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001301 const llvm::Triple &Triple) {
1302 // We use the zero-cost exception tables for Objective-C if the non-fragile
1303 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1304 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001305 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001306 return true;
1307
Bob Wilson6524dd32011-10-14 05:03:44 +00001308 if (!Triple.isOSDarwin())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001309 return false;
1310
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001311 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001312 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001313 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001314}
1315
Anders Carlssone96ab552011-02-28 02:27:16 +00001316/// addExceptionArgs - Adds exception related arguments to the driver command
1317/// arguments. There's a master flag, -fexceptions and also language specific
1318/// flags to enable/disable C++ and Objective-C exceptions.
1319/// This makes it possible to for example disable C++ exceptions but enable
1320/// Objective-C exceptions.
1321static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1322 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001323 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001324 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001325 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001326 if (KernelOrKext) {
1327 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1328 // arguments now to avoid warnings about unused arguments.
1329 Args.ClaimAllArgs(options::OPT_fexceptions);
1330 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1331 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1332 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1333 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1334 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001335 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001336 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001337
1338 // Exceptions are enabled by default.
1339 bool ExceptionsEnabled = true;
1340
1341 // This keeps track of whether exceptions were explicitly turned on or off.
1342 bool DidHaveExplicitExceptionFlag = false;
1343
Rafael Espindola00a66572009-10-01 13:33:33 +00001344 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1345 options::OPT_fno_exceptions)) {
1346 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001347 ExceptionsEnabled = true;
Eric Christopher84fbdb42011-08-19 00:30:14 +00001348 else
Anders Carlssone96ab552011-02-28 02:27:16 +00001349 ExceptionsEnabled = false;
1350
1351 DidHaveExplicitExceptionFlag = true;
Rafael Espindola00a66572009-10-01 13:33:33 +00001352 }
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001353
Anders Carlssone96ab552011-02-28 02:27:16 +00001354 bool ShouldUseExceptionTables = false;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +00001355
Anders Carlssone96ab552011-02-28 02:27:16 +00001356 // Exception tables and cleanups can be enabled with -fexceptions even if the
1357 // language itself doesn't support exceptions.
1358 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1359 ShouldUseExceptionTables = true;
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001360
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001361 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1362 // is not necessarily sensible, but follows GCC.
1363 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001364 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001365 options::OPT_fno_objc_exceptions,
1366 true)) {
1367 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001368
Eric Christopher84fbdb42011-08-19 00:30:14 +00001369 ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001370 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001371 }
1372
1373 if (types::isCXX(InputType)) {
1374 bool CXXExceptionsEnabled = ExceptionsEnabled;
1375
Eric Christopher84fbdb42011-08-19 00:30:14 +00001376 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1377 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001378 options::OPT_fexceptions,
1379 options::OPT_fno_exceptions)) {
1380 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1381 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001382 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001383 CXXExceptionsEnabled = false;
1384 }
1385
1386 if (CXXExceptionsEnabled) {
1387 CmdArgs.push_back("-fcxx-exceptions");
1388
1389 ShouldUseExceptionTables = true;
1390 }
1391 }
1392
1393 if (ShouldUseExceptionTables)
1394 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001395}
1396
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001397static bool ShouldDisableCFI(const ArgList &Args,
1398 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001399 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001400 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001401 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001402 // we disable them if we think the .s file will be passed to it.
Rafael Espindolac41db922012-03-08 14:39:55 +00001403 Default = Args.hasFlag(options::OPT_integrated_as,
Eric Christopher45f2e712012-12-18 00:31:10 +00001404 options::OPT_no_integrated_as,
1405 TC.IsIntegratedAssemblerDefault());
Rafael Espindolaf934f982011-05-17 16:26:17 +00001406 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001407 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
Eric Christopher45f2e712012-12-18 00:31:10 +00001408 options::OPT_fno_dwarf2_cfi_asm,
1409 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001410}
1411
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001412static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1413 const ToolChain &TC) {
1414 bool IsIADefault = TC.IsIntegratedAssemblerDefault();
1415 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1416 options::OPT_no_integrated_as,
1417 IsIADefault);
1418 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1419 options::OPT_fno_dwarf_directory_asm,
1420 UseIntegratedAs);
1421 return !UseDwarfDirectory;
1422}
1423
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001424/// \brief Check whether the given input tree contains any compilation actions.
1425static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001426 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001427 return true;
1428
1429 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1430 if (ContainsCompileAction(*it))
1431 return true;
1432
1433 return false;
1434}
1435
1436/// \brief Check if -relax-all should be passed to the internal assembler.
1437/// This is done by default when compiling non-assembler source with -O0.
1438static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1439 bool RelaxDefault = true;
1440
1441 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1442 RelaxDefault = A->getOption().matches(options::OPT_O0);
1443
1444 if (RelaxDefault) {
1445 RelaxDefault = false;
1446 for (ActionList::const_iterator it = C.getActions().begin(),
1447 ie = C.getActions().end(); it != ie; ++it) {
1448 if (ContainsCompileAction(*it)) {
1449 RelaxDefault = true;
1450 break;
1451 }
1452 }
1453 }
1454
1455 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1456 RelaxDefault);
1457}
1458
Alexey Samsonovf7a24762013-01-16 11:34:36 +00001459SanitizerArgs::SanitizerArgs(const Driver &D, const ArgList &Args)
Alexey Samsonov29524a92013-01-20 13:12:12 +00001460 : Kind(0), BlacklistFile(""), MsanTrackOrigins(false),
1461 AsanZeroBaseShadow(false) {
Alexey Samsonov2cbcf1a2013-01-28 07:20:44 +00001462 unsigned AllKinds = 0; // All kinds of sanitizers that were turned on
1463 // at least once (possibly, disabled further).
Richard Smith52be6192012-11-05 22:04:41 +00001464 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
Alexey Samsonov53f7e122012-11-28 17:34:24 +00001465 unsigned Add, Remove;
1466 if (!parse(D, Args, *I, Add, Remove, true))
Richard Smith52be6192012-11-05 22:04:41 +00001467 continue;
Richard Smith52be6192012-11-05 22:04:41 +00001468 (*I)->claim();
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001469 Kind |= Add;
1470 Kind &= ~Remove;
Alexey Samsonov2cbcf1a2013-01-28 07:20:44 +00001471 AllKinds |= Add;
Richard Smith52be6192012-11-05 22:04:41 +00001472 }
1473
Chad Rosierae229d52013-01-29 23:31:22 +00001474 UbsanTrapOnError =
1475 Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
1476 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
1477 options::OPT_fno_sanitize_undefined_trap_on_error, false);
1478
1479 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) &&
1480 !Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
1481 options::OPT_fno_sanitize_undefined_trap_on_error, true)) {
1482 D.Diag(diag::err_drv_argument_not_allowed_with)
1483 << "-fcatch-undefined-behavior"
1484 << "-fno-sanitize-undefined-trap-on-error";
1485 }
1486
1487 // Warn about undefined sanitizer options that require runtime support.
1488 if (UbsanTrapOnError && notAllowedWithTrap()) {
1489 if (Args.hasArg(options::OPT_fcatch_undefined_behavior))
1490 D.Diag(diag::err_drv_argument_not_allowed_with)
1491 << lastArgumentForKind(D, Args, NotAllowedWithTrap)
1492 << "-fcatch-undefined-behavior";
1493 else if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
1494 options::OPT_fno_sanitize_undefined_trap_on_error,
1495 false))
1496 D.Diag(diag::err_drv_argument_not_allowed_with)
1497 << lastArgumentForKind(D, Args, NotAllowedWithTrap)
1498 << "-fsanitize-undefined-trap-on-error";
1499 }
1500
Richard Smith52be6192012-11-05 22:04:41 +00001501 // Only one runtime library can be used at once.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001502 bool NeedsAsan = needsAsanRt();
1503 bool NeedsTsan = needsTsanRt();
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001504 bool NeedsMsan = needsMsanRt();
Richard Smith06d87f12012-12-01 01:02:45 +00001505 if (NeedsAsan && NeedsTsan)
Richard Smith52be6192012-11-05 22:04:41 +00001506 D.Diag(diag::err_drv_argument_not_allowed_with)
Richard Smith06d87f12012-12-01 01:02:45 +00001507 << lastArgumentForKind(D, Args, NeedsAsanRt)
1508 << lastArgumentForKind(D, Args, NeedsTsanRt);
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001509 if (NeedsAsan && NeedsMsan)
1510 D.Diag(diag::err_drv_argument_not_allowed_with)
1511 << lastArgumentForKind(D, Args, NeedsAsanRt)
1512 << lastArgumentForKind(D, Args, NeedsMsanRt);
1513 if (NeedsTsan && NeedsMsan)
1514 D.Diag(diag::err_drv_argument_not_allowed_with)
1515 << lastArgumentForKind(D, Args, NeedsTsanRt)
1516 << lastArgumentForKind(D, Args, NeedsMsanRt);
Alexey Samsonov0e96bec2012-11-29 22:36:21 +00001517
1518 // If -fsanitize contains extra features of ASan, it should also
Alexey Samsonov2cbcf1a2013-01-28 07:20:44 +00001519 // explicitly contain -fsanitize=address (probably, turned off later in the
1520 // command line).
1521 if ((Kind & AddressFull) != 0 && (AllKinds & Address) == 0)
1522 D.Diag(diag::warn_drv_unused_sanitizer)
1523 << lastArgumentForKind(D, Args, AddressFull)
1524 << "-fsanitize=address";
Alexey Samsonov9ab73622012-12-03 19:12:58 +00001525
1526 // Parse -f(no-)sanitize-blacklist options.
1527 if (Arg *BLArg = Args.getLastArg(options::OPT_fsanitize_blacklist,
1528 options::OPT_fno_sanitize_blacklist)) {
1529 if (BLArg->getOption().matches(options::OPT_fsanitize_blacklist)) {
1530 std::string BLPath = BLArg->getValue();
1531 bool BLExists = false;
1532 if (!llvm::sys::fs::exists(BLPath, BLExists) && BLExists)
1533 BlacklistFile = BLPath;
1534 else
1535 D.Diag(diag::err_drv_no_such_file) << BLPath;
1536 }
1537 }
Evgeniy Stepanovad8ab3d2012-12-24 08:42:34 +00001538
1539 // Parse -f(no-)sanitize-memory-track-origins options.
Alexey Samsonov29524a92013-01-20 13:12:12 +00001540 if (NeedsMsan)
Evgeniy Stepanovad8ab3d2012-12-24 08:42:34 +00001541 MsanTrackOrigins =
1542 Args.hasFlag(options::OPT_fsanitize_memory_track_origins,
1543 options::OPT_fno_sanitize_memory_track_origins,
1544 /* Default */false);
Alexey Samsonov29524a92013-01-20 13:12:12 +00001545
1546 // Parse -f(no-)sanitize-address-zero-base-shadow options.
1547 if (NeedsAsan)
1548 AsanZeroBaseShadow =
1549 Args.hasFlag(options::OPT_fsanitize_address_zero_base_shadow,
1550 options::OPT_fno_sanitize_address_zero_base_shadow,
1551 /* Default */false);
Richard Smith52be6192012-11-05 22:04:41 +00001552}
1553
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001554/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1555/// This needs to be called before we add the C run-time (malloc, etc).
1556static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00001557 ArgStringList &CmdArgs) {
Logan Chienc6fd8202012-09-02 09:30:11 +00001558 if(TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001559 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovea155f02012-06-04 11:15:05 +00001560 if (!Args.hasArg(options::OPT_pie))
1561 TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001562 }
Daniel Dunbar3ca41d42011-12-07 23:22:17 +00001563
Evgeniy Stepanovcac6aaa2012-09-12 09:09:08 +00001564 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1565 llvm::sys::path::append(LibAsan, "lib", "linux",
1566 (Twine("libclang_rt.asan-") +
1567 TC.getArchName() + "-android.so"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001568 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001569 } else {
1570 if (!Args.hasArg(options::OPT_shared)) {
Alexey Samsonov29524a92013-01-20 13:12:12 +00001571 bool ZeroBaseShadow = Args.hasFlag(
1572 options::OPT_fsanitize_address_zero_base_shadow,
1573 options::OPT_fno_sanitize_address_zero_base_shadow, false);
1574 if (ZeroBaseShadow && !Args.hasArg(options::OPT_pie)) {
1575 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1576 "-fsanitize-address-zero-base-shadow" << "-pie";
1577 }
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001578 // LibAsan is "libclang_rt.asan-<ArchName>.a" in the Linux library
1579 // resource directory.
1580 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1581 llvm::sys::path::append(LibAsan, "lib", "linux",
1582 (Twine("libclang_rt.asan-") +
1583 TC.getArchName() + ".a"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001584 // The ASan runtime needs to come before -lstdc++ (or -lc++, libstdc++.a,
1585 // etc.) so that the linker picks ASan's versions of the global 'operator
1586 // new' and 'operator delete' symbols. We take the extreme (but simple)
Chandler Carruth210c77b2012-12-04 22:54:37 +00001587 // strategy of inserting it at the front of the link command. It also
1588 // needs to be forced to end up in the executable, so wrap it in
1589 // whole-archive.
1590 SmallVector<const char*, 3> PrefixArgs;
1591 PrefixArgs.push_back("-whole-archive");
1592 PrefixArgs.push_back(Args.MakeArgString(LibAsan));
1593 PrefixArgs.push_back("-no-whole-archive");
1594 CmdArgs.insert(CmdArgs.begin(), PrefixArgs.begin(), PrefixArgs.end());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001595 CmdArgs.push_back("-lpthread");
1596 CmdArgs.push_back("-ldl");
1597 CmdArgs.push_back("-export-dynamic");
1598 }
1599 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001600}
1601
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001602/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1603/// This needs to be called before we add the C run-time (malloc, etc).
1604static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1605 ArgStringList &CmdArgs) {
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001606 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001607 if (!Args.hasArg(options::OPT_pie))
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001608 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1609 "-fsanitize=thread" << "-pie";
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001610 // LibTsan is "libclang_rt.tsan-<ArchName>.a" in the Linux library
1611 // resource directory.
1612 SmallString<128> LibTsan(TC.getDriver().ResourceDir);
1613 llvm::sys::path::append(LibTsan, "lib", "linux",
1614 (Twine("libclang_rt.tsan-") +
1615 TC.getArchName() + ".a"));
1616 CmdArgs.push_back(Args.MakeArgString(LibTsan));
1617 CmdArgs.push_back("-lpthread");
1618 CmdArgs.push_back("-ldl");
1619 CmdArgs.push_back("-export-dynamic");
1620 }
1621}
1622
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001623/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1624/// This needs to be called before we add the C run-time (malloc, etc).
1625static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1626 ArgStringList &CmdArgs) {
1627 if (!Args.hasArg(options::OPT_shared)) {
1628 if (!Args.hasArg(options::OPT_pie))
Evgeniy Stepanovcdc22552012-12-05 13:37:12 +00001629 TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1630 "-fsanitize=memory" << "-pie";
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001631 // LibMsan is "libclang_rt.msan-<ArchName>.a" in the Linux library
1632 // resource directory.
1633 SmallString<128> LibMsan(TC.getDriver().ResourceDir);
1634 llvm::sys::path::append(LibMsan, "lib", "linux",
1635 (Twine("libclang_rt.msan-") +
1636 TC.getArchName() + ".a"));
1637 CmdArgs.push_back(Args.MakeArgString(LibMsan));
1638 CmdArgs.push_back("-lpthread");
1639 CmdArgs.push_back("-ldl");
1640 CmdArgs.push_back("-export-dynamic");
1641 }
1642}
1643
Richard Smithe30752c2012-10-09 19:52:38 +00001644/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1645/// (Linux).
1646static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1647 ArgStringList &CmdArgs) {
Richard Smithf75c8b32013-01-18 22:09:26 +00001648 // LibUbsan is "libclang_rt.ubsan-<ArchName>.a" in the Linux library
1649 // resource directory.
1650 SmallString<128> LibUbsan(TC.getDriver().ResourceDir);
1651 llvm::sys::path::append(LibUbsan, "lib", "linux",
1652 (Twine("libclang_rt.ubsan-") +
1653 TC.getArchName() + ".a"));
1654 CmdArgs.push_back(Args.MakeArgString(LibUbsan));
1655 CmdArgs.push_back("-lpthread");
1656 CmdArgs.push_back("-export-dynamic");
Richard Smithe30752c2012-10-09 19:52:38 +00001657}
1658
Rafael Espindola224dd632011-12-14 21:02:23 +00001659static bool shouldUseFramePointer(const ArgList &Args,
1660 const llvm::Triple &Triple) {
1661 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1662 options::OPT_fomit_frame_pointer))
1663 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1664
Rafael Espindola00b29182011-12-14 21:50:24 +00001665 // Don't use a frame pointer on linux x86 and x86_64 if optimizing.
Rafael Espindola224dd632011-12-14 21:02:23 +00001666 if ((Triple.getArch() == llvm::Triple::x86_64 ||
1667 Triple.getArch() == llvm::Triple::x86) &&
1668 Triple.getOS() == llvm::Triple::Linux) {
1669 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1670 if (!A->getOption().matches(options::OPT_O0))
1671 return false;
1672 }
1673
1674 return true;
1675}
1676
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00001677/// If the PWD environment variable is set, add a CC1 option to specify the
1678/// debug compilation directory.
1679static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1680 if (const char *pwd = ::getenv("PWD")) {
1681 // GCC also verifies that stat(pwd) and stat(".") have the same inode
1682 // number. Not doing those because stats are slow, but we could.
1683 if (llvm::sys::path::is_absolute(pwd)) {
1684 std::string CompDir = pwd;
1685 CmdArgs.push_back("-fdebug-compilation-dir");
1686 CmdArgs.push_back(Args.MakeArgString(CompDir));
1687 }
1688 }
1689}
1690
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001691void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00001692 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00001693 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001694 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001695 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00001696 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1697 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00001698 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00001699 ArgStringList CmdArgs;
1700
Daniel Dunbare521a892009-03-31 20:53:55 +00001701 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1702
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00001703 // Invoke ourselves in -cc1 mode.
1704 //
1705 // FIXME: Implement custom jobs for internal actions.
1706 CmdArgs.push_back("-cc1");
1707
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001708 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00001709 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00001710 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001711 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00001712
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001713 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00001714 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00001715
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001716 if (isa<AnalyzeJobAction>(JA)) {
1717 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1718 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00001719 } else if (isa<MigrateJobAction>(JA)) {
1720 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001721 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001722 if (Output.getType() == types::TY_Dependencies)
1723 CmdArgs.push_back("-Eonly");
1724 else
1725 CmdArgs.push_back("-E");
Daniel Dunbarc4343942010-02-03 03:07:56 +00001726 } else if (isa<AssembleJobAction>(JA)) {
1727 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001728
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001729 if (UseRelaxAll(C, Args))
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001730 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001731
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001732 // When using an integrated assembler, translate -Wa, and -Xassembler
1733 // options.
1734 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1735 options::OPT_Xassembler),
1736 ie = Args.filtered_end(); it != ie; ++it) {
1737 const Arg *A = *it;
1738 A->claim();
1739
1740 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001741 StringRef Value = A->getValue(i);
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001742
1743 if (Value == "-force_cpusubtype_ALL") {
1744 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbara78e5892010-10-28 20:36:23 +00001745 } else if (Value == "-L") {
Daniel Dunbar67919b22011-03-28 22:49:28 +00001746 CmdArgs.push_back("-msave-temp-labels");
Joerg Sonnenberger3028e462011-05-19 20:46:39 +00001747 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergerb487d2d2011-05-19 18:42:29 +00001748 CmdArgs.push_back("-mllvm");
1749 CmdArgs.push_back("-fatal-assembler-warnings");
Nick Lewyckyca6b90d2011-06-21 00:14:18 +00001750 } else if (Value == "--noexecstack") {
1751 CmdArgs.push_back("-mnoexecstack");
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001752 } else {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001753 D.Diag(diag::err_drv_unsupported_option_argument)
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001754 << A->getOption().getName() << Value;
1755 }
1756 }
1757 }
Daniel Dunbar7c874332010-11-19 16:23:35 +00001758
1759 // Also ignore explicit -force_cpusubtype_ALL option.
1760 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001761 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00001762 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001763 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001764
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001765 if (JA.getType() == types::TY_Nothing)
1766 CmdArgs.push_back("-fsyntax-only");
1767 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00001768 CmdArgs.push_back("-emit-pch");
1769 else
1770 CmdArgs.push_back("-emit-pth");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001771 } else {
1772 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001773
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001774 if (JA.getType() == types::TY_Nothing) {
1775 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001776 } else if (JA.getType() == types::TY_LLVM_IR ||
1777 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001778 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001779 } else if (JA.getType() == types::TY_LLVM_BC ||
1780 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001781 CmdArgs.push_back("-emit-llvm-bc");
1782 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00001783 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001784 } else if (JA.getType() == types::TY_AST) {
1785 CmdArgs.push_back("-emit-pch");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001786 } else if (JA.getType() == types::TY_RewrittenObjC) {
1787 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001788 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00001789 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1790 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001791 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001792 } else {
1793 assert(JA.getType() == types::TY_PP_Asm &&
1794 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001795 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001796 }
1797
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001798 // The make clang go fast button.
1799 CmdArgs.push_back("-disable-free");
1800
John McCallbb79b5f2010-02-13 03:50:24 +00001801 // Disable the verification pass in -asserts builds.
1802#ifdef NDEBUG
1803 CmdArgs.push_back("-disable-llvm-verifier");
1804#endif
1805
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001806 // Set the main file name, so that debug info works even with
1807 // -save-temps.
1808 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00001809 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001810
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001811 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00001812 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001813 if (Args.hasArg(options::OPT_static))
1814 CmdArgs.push_back("-static-define");
1815
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001816 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00001817 // Enable region store model by default.
1818 CmdArgs.push_back("-analyzer-store=region");
1819
Ted Kremenek7bea9a12009-12-07 22:26:14 +00001820 // Treat blocks as analysis entry points.
1821 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1822
Ted Kremenek49c79792011-03-24 00:28:47 +00001823 CmdArgs.push_back("-analyzer-eagerly-assume");
1824
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001825 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001826 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001827 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00001828
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001829 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1830 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00001831
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001832 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00001833 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00001834
1835 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00001836
1837 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00001838 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
1839 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
1840 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
1841 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
1842 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
1843 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001844 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001845
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001846 // Set the output format. The default is plist, for (lame) historical
1847 // reasons.
1848 CmdArgs.push_back("-analyzer-output");
1849 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00001850 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001851 else
1852 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001853
Ted Kremenekfe449a22010-03-22 22:32:05 +00001854 // Disable the presentation of standard compiler warnings when
1855 // using --analyze. We only want to show static analyzer diagnostics
1856 // or frontend errors.
1857 CmdArgs.push_back("-w");
1858
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001859 // Add -Xanalyzer arguments when running as analyzer.
1860 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00001861 }
1862
Daniel Dunbar4eadb602009-09-10 01:21:12 +00001863 CheckCodeGenerationOptions(D, Args);
1864
Chandler Carruth76a943b2012-11-19 03:52:03 +00001865 // For the PIC and PIE flag options, this logic is different from the legacy
1866 // logic in very old versions of GCC, as that logic was just a bug no one had
1867 // ever fixed. This logic is both more rational and consistent with GCC's new
1868 // logic now that the bugs are fixed. The last argument relating to either
1869 // PIC or PIE wins, and no other argument is used. If the last argument is
1870 // any flavor of the '-fno-...' arguments, both PIC and PIE are disabled. Any
1871 // PIE option implicitly enables PIC at the same level.
1872 bool PIE = false;
1873 bool PIC = getToolChain().isPICDefault();
1874 bool IsPICLevelTwo = PIC;
1875 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1876 options::OPT_fpic, options::OPT_fno_pic,
1877 options::OPT_fPIE, options::OPT_fno_PIE,
1878 options::OPT_fpie, options::OPT_fno_pie)) {
1879 Option O = A->getOption();
1880 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1881 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1882 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1883 PIC = PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1884 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
1885 O.matches(options::OPT_fPIC);
1886 } else {
1887 PIE = PIC = false;
1888 }
Benjamin Kramer76db2902012-11-13 15:32:35 +00001889 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00001890 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
1891 // is forced, then neither PIC nor PIE flags will have no effect.
1892 if (getToolChain().isPICDefaultForced()) {
1893 PIE = false;
1894 PIC = getToolChain().isPICDefault();
1895 IsPICLevelTwo = PIC;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001896 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00001897
1898 // Inroduce a Darwin-specific hack. If the default is PIC but the flags
1899 // specified while enabling PIC enabled level 1 PIC, just force it back to
1900 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
1901 // informal testing).
1902 if (PIC && getToolChain().getTriple().isOSDarwin())
1903 IsPICLevelTwo |= getToolChain().isPICDefault();
1904
Chandler Carruthc0c04552012-04-08 16:40:35 +00001905 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
1906 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00001907 llvm::Triple Triple(TripleStr);
1908 if ((Args.hasArg(options::OPT_mkernel) ||
1909 Args.hasArg(options::OPT_fapple_kext)) &&
1910 (Triple.getOS() != llvm::Triple::IOS ||
1911 Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00001912 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001913 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00001914 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00001915
Chandler Carruth76a943b2012-11-19 03:52:03 +00001916 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1917 // This is a very special mode. It trumps the other modes, almost no one
1918 // uses it, and it isn't even valid on any OS but Darwin.
1919 if (!getToolChain().getTriple().isOSDarwin())
1920 D.Diag(diag::err_drv_unsupported_opt_for_target)
1921 << A->getSpelling() << getToolChain().getTriple().str();
1922
1923 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
1924
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001925 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00001926 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00001927
Chandler Carruth76a943b2012-11-19 03:52:03 +00001928 // Only a forced PIC mode can cause the actual compile to have PIC defines
1929 // etc., no flags are sufficient. This behavior was selected to closely
1930 // match that of llvm-gcc and Apple GCC before that.
1931 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
1932 CmdArgs.push_back("-pic-level");
1933 CmdArgs.push_back("2");
1934 }
1935 } else {
1936 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
1937 // handled in Clang's IRGen by the -pie-level flag.
1938 CmdArgs.push_back("-mrelocation-model");
1939 CmdArgs.push_back(PIC ? "pic" : "static");
1940
1941 if (PIC) {
1942 CmdArgs.push_back("-pic-level");
1943 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
1944 if (PIE) {
1945 CmdArgs.push_back("-pie-level");
1946 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
1947 }
1948 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00001949 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00001950
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00001951 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1952 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00001953 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00001954
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001955 // LLVM Code Generator Options.
1956
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001957 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1958 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00001959 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001960 }
1961
Roman Divacky65b88cd2011-03-01 17:40:53 +00001962 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1963 CmdArgs.push_back("-mrtd");
1964
Rafael Espindola224dd632011-12-14 21:02:23 +00001965 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001966 CmdArgs.push_back("-mdisable-fp-elim");
1967 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1968 options::OPT_fno_zero_initialized_in_bss))
1969 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Daniel Dunbar7aa71f92011-02-04 02:20:39 +00001970 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1971 options::OPT_fno_strict_aliasing,
1972 getToolChain().IsStrictAliasingDefault()))
Dan Gohman10169b92010-10-14 22:36:56 +00001973 CmdArgs.push_back("-relaxed-aliasing");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00001974 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
1975 false))
1976 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00001977 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
1978 options::OPT_fno_optimize_sibling_calls))
1979 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00001980
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001981 // Handle various floating point optimization flags, mapping them to the
1982 // appropriate LLVM code generation flags. The pattern for all of these is to
1983 // default off the codegen optimizations, and if any flag enables them and no
1984 // flag disables them after the flag enabling them, enable the codegen
1985 // optimization. This is complicated by several "umbrella" flags.
1986 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001987 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001988 options::OPT_ffinite_math_only,
1989 options::OPT_fno_finite_math_only,
1990 options::OPT_fhonor_infinities,
1991 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001992 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1993 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001994 A->getOption().getID() != options::OPT_fhonor_infinities)
1995 CmdArgs.push_back("-menable-no-infs");
1996 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001997 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001998 options::OPT_ffinite_math_only,
1999 options::OPT_fno_finite_math_only,
2000 options::OPT_fhonor_nans,
2001 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002002 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2003 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002004 A->getOption().getID() != options::OPT_fhonor_nans)
2005 CmdArgs.push_back("-menable-no-nans");
2006
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002007 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2008 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002009 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002010 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002011 options::OPT_fmath_errno,
Chandler Carruth3634c662012-04-26 02:10:51 +00002012 options::OPT_fno_math_errno))
2013 MathErrno = A->getOption().getID() == options::OPT_fmath_errno;
2014 if (MathErrno)
2015 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002016
2017 // There are several flags which require disabling very specific
2018 // optimizations. Any of these being disabled forces us to turn off the
2019 // entire set of LLVM optimizations, so collect them through all the flag
2020 // madness.
2021 bool AssociativeMath = false;
2022 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002023 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002024 options::OPT_funsafe_math_optimizations,
2025 options::OPT_fno_unsafe_math_optimizations,
2026 options::OPT_fassociative_math,
2027 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002028 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2029 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002030 A->getOption().getID() != options::OPT_fno_associative_math)
2031 AssociativeMath = true;
2032 bool ReciprocalMath = false;
2033 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002034 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002035 options::OPT_funsafe_math_optimizations,
2036 options::OPT_fno_unsafe_math_optimizations,
2037 options::OPT_freciprocal_math,
2038 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002039 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2040 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002041 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2042 ReciprocalMath = true;
2043 bool SignedZeros = true;
2044 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002045 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002046 options::OPT_funsafe_math_optimizations,
2047 options::OPT_fno_unsafe_math_optimizations,
2048 options::OPT_fsigned_zeros,
2049 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002050 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2051 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002052 A->getOption().getID() != options::OPT_fsigned_zeros)
2053 SignedZeros = false;
2054 bool TrappingMath = true;
2055 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002056 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002057 options::OPT_funsafe_math_optimizations,
2058 options::OPT_fno_unsafe_math_optimizations,
2059 options::OPT_ftrapping_math,
2060 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002061 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2062 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002063 A->getOption().getID() != options::OPT_ftrapping_math)
2064 TrappingMath = false;
2065 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2066 !TrappingMath)
2067 CmdArgs.push_back("-menable-unsafe-fp-math");
2068
Lang Hamesaa53b932012-07-06 00:59:19 +00002069
2070 // Validate and pass through -fp-contract option.
2071 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002072 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002073 options::OPT_ffp_contract)) {
2074 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002075 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002076 if (Val == "fast" || Val == "on" || Val == "off") {
2077 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2078 } else {
2079 D.Diag(diag::err_drv_unsupported_option_argument)
2080 << A->getOption().getName() << Val;
2081 }
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002082 } else if (A->getOption().getID() == options::OPT_ffast_math) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002083 // If fast-math is set then set the fp-contract mode to fast.
2084 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2085 }
2086 }
2087
Bob Wilson6a039162012-07-19 03:52:53 +00002088 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2089 // and if we find them, tell the frontend to provide the appropriate
2090 // preprocessor macros. This is distinct from enabling any optimizations as
2091 // these options induce language changes which must survive serialization
2092 // and deserialization, etc.
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002093 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math))
2094 if (A->getOption().matches(options::OPT_ffast_math))
2095 CmdArgs.push_back("-ffast-math");
2096 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2097 if (A->getOption().matches(options::OPT_ffinite_math_only))
2098 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002099
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002100 // Decide whether to use verbose asm. Verbose assembly is the default on
2101 // toolchains which have the integrated assembler on by default.
2102 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2103 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002104 IsVerboseAsmDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002105 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002106 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002107
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002108 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2109 CmdArgs.push_back("-mdebug-pass");
2110 CmdArgs.push_back("Structure");
2111 }
2112 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2113 CmdArgs.push_back("-mdebug-pass");
2114 CmdArgs.push_back("Arguments");
2115 }
2116
John McCall8517abc2010-02-19 02:45:38 +00002117 // Enable -mconstructor-aliases except on darwin, where we have to
2118 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002119 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002120 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002121
John McCall7ef5cb32011-03-18 02:56:14 +00002122 // Darwin's kernel doesn't support guard variables; just die if we
2123 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002124 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002125 CmdArgs.push_back("-fforbid-guard-variables");
2126
Douglas Gregordbe39272011-02-01 15:15:22 +00002127 if (Args.hasArg(options::OPT_mms_bitfields)) {
2128 CmdArgs.push_back("-mms-bitfields");
2129 }
John McCall8517abc2010-02-19 02:45:38 +00002130
Daniel Dunbar306945d2009-09-16 06:17:29 +00002131 // This is a coarse approximation of what llvm-gcc actually does, both
2132 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2133 // complicated ways.
2134 bool AsynchronousUnwindTables =
2135 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2136 options::OPT_fno_asynchronous_unwind_tables,
2137 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002138 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002139 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2140 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002141 CmdArgs.push_back("-munwind-tables");
2142
Chandler Carruth05fb5852012-11-21 23:40:23 +00002143 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002144
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002145 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2146 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002147 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002148 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002149
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002150 // FIXME: Handle -mtune=.
2151 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002152
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002153 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002154 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002155 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002156 }
2157
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002158 // Add target specific cpu and features flags.
2159 switch(getToolChain().getTriple().getArch()) {
2160 default:
2161 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002162
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002163 case llvm::Triple::arm:
2164 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002165 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002166 break;
2167
Eric Christopher0b26a612010-03-02 02:41:08 +00002168 case llvm::Triple::mips:
2169 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002170 case llvm::Triple::mips64:
2171 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002172 AddMIPSTargetArgs(Args, CmdArgs);
2173 break;
2174
Hal Finkel8eb59282012-06-11 22:35:19 +00002175 case llvm::Triple::ppc:
2176 case llvm::Triple::ppc64:
2177 AddPPCTargetArgs(Args, CmdArgs);
2178 break;
2179
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002180 case llvm::Triple::sparc:
2181 AddSparcTargetArgs(Args, CmdArgs);
2182 break;
2183
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002184 case llvm::Triple::x86:
2185 case llvm::Triple::x86_64:
2186 AddX86TargetArgs(Args, CmdArgs);
2187 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002188
2189 case llvm::Triple::hexagon:
2190 AddHexagonTargetArgs(Args, CmdArgs);
2191 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002192 }
2193
Tony Linthicum76329bf2011-12-12 21:14:55 +00002194
2195
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002196 // Pass the linker version in use.
2197 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2198 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002199 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002200 }
2201
Nick Lewycky75033772011-02-02 06:43:03 +00002202 // -mno-omit-leaf-frame-pointer is the default on Darwin.
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002203 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
Nick Lewycky75033772011-02-02 06:43:03 +00002204 options::OPT_mno_omit_leaf_frame_pointer,
Bob Wilson6524dd32011-10-14 05:03:44 +00002205 !getToolChain().getTriple().isOSDarwin()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002206 CmdArgs.push_back("-momit-leaf-frame-pointer");
2207
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002208 // Explicitly error on some things we know we don't support and can't just
2209 // ignore.
2210 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002211 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2212 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002213 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002214 getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002215 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002216 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2217 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002218 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002219 << Unsupported->getOption().getName();
2220 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002221 }
2222
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002223 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002224 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002225 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002226 CmdArgs.push_back("-header-include-file");
2227 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2228 D.CCPrintHeadersFilename : "-");
2229 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002230 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002231 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002232
Chad Rosierbe10f982011-08-02 17:58:04 +00002233 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002234 CmdArgs.push_back("-diagnostic-log-file");
2235 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2236 D.CCLogDiagnosticsFilename : "-");
2237 }
2238
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002239 // Use the last option from "-g" group. "-gline-tables-only"
2240 // is preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002241 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002242 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002243 if (A->getOption().matches(options::OPT_gline_tables_only))
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002244 CmdArgs.push_back("-gline-tables-only");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002245 else if (!A->getOption().matches(options::OPT_g0) &&
2246 !A->getOption().matches(options::OPT_ggdb0))
Chad Rosier8fe3b112011-11-07 19:52:29 +00002247 CmdArgs.push_back("-g");
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002248 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002249
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002250 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2251 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002252 if (Args.hasArg(options::OPT_gcolumn_info))
2253 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002254
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002255 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2256 // splitting and extraction.
2257 if (Args.hasArg(options::OPT_gsplit_dwarf)) {
2258 CmdArgs.push_back("-g");
2259 CmdArgs.push_back("-backend-option");
2260 CmdArgs.push_back("-split-dwarf=Enable");
2261 }
2262
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002263 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2264 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2265
Chris Lattner3c77a352010-06-22 00:03:40 +00002266 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2267
Nick Lewycky207bce32011-04-21 23:44:07 +00002268 if (Args.hasArg(options::OPT_ftest_coverage) ||
2269 Args.hasArg(options::OPT_coverage))
2270 CmdArgs.push_back("-femit-coverage-notes");
2271 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2272 Args.hasArg(options::OPT_coverage))
2273 CmdArgs.push_back("-femit-coverage-data");
2274
Nick Lewycky480cb992011-05-04 20:46:58 +00002275 if (C.getArgs().hasArg(options::OPT_c) ||
2276 C.getArgs().hasArg(options::OPT_S)) {
2277 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002278 CmdArgs.push_back("-coverage-file");
Bill Wendling8c0b4bc2012-08-30 00:43:41 +00002279 SmallString<128> absFilename(Output.getFilename());
2280 llvm::sys::fs::make_absolute(absFilename);
2281 CmdArgs.push_back(Args.MakeArgString(absFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002282 }
2283 }
2284
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002285 // Pass options for controlling the default header search paths.
2286 if (Args.hasArg(options::OPT_nostdinc)) {
2287 CmdArgs.push_back("-nostdsysteminc");
2288 CmdArgs.push_back("-nobuiltininc");
2289 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002290 if (Args.hasArg(options::OPT_nostdlibinc))
2291 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002292 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2293 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2294 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002295
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002296 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002297 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002298 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002299
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002300 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2301
Ted Kremenekf7639e12012-03-06 20:06:33 +00002302 bool ARCMTEnabled = false;
John McCalld70fb982011-06-15 23:25:17 +00002303 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002304 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002305 options::OPT_ccc_arcmt_modify,
2306 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002307 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002308 switch (A->getOption().getID()) {
2309 default:
2310 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002311 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002312 CmdArgs.push_back("-arcmt-check");
2313 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002314 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002315 CmdArgs.push_back("-arcmt-modify");
2316 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002317 case options::OPT_ccc_arcmt_migrate:
2318 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002319 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002320 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002321
2322 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2323 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002324 break;
John McCalld70fb982011-06-15 23:25:17 +00002325 }
2326 }
2327 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002328
Ted Kremenekf7639e12012-03-06 20:06:33 +00002329 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2330 if (ARCMTEnabled) {
2331 D.Diag(diag::err_drv_argument_not_allowed_with)
2332 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2333 }
2334 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002335 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002336
2337 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2338 options::OPT_objcmt_migrate_subscripting)) {
2339 // None specified, means enable them all.
2340 CmdArgs.push_back("-objcmt-migrate-literals");
2341 CmdArgs.push_back("-objcmt-migrate-subscripting");
2342 } else {
2343 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2344 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2345 }
2346 }
2347
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002348 // Add preprocessing options like -I, -D, etc. if we are using the
2349 // preprocessor.
2350 //
2351 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002352 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00002353 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002354
Rafael Espindolaa7431922011-07-21 23:40:37 +00002355 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2356 // that "The compiler can only warn and ignore the option if not recognized".
2357 // When building with ccache, it will pass -D options to clang even on
2358 // preprocessed inputs and configure concludes that -fPIC is not supported.
2359 Args.ClaimAllArgs(options::OPT_D);
2360
Daniel Dunbar58f78332009-09-17 06:53:36 +00002361 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar13864952009-03-24 20:17:30 +00002362 // others.
2363 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00002364 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar13864952009-03-24 20:17:30 +00002365 CmdArgs.push_back("-O3");
Daniel Dunbar9296f632010-05-27 06:51:08 +00002366 else if (A->getOption().matches(options::OPT_O) &&
Richard Smithbd55daf2012-11-01 04:30:05 +00002367 A->getValue()[0] == '\0')
Daniel Dunbar58f78332009-09-17 06:53:36 +00002368 CmdArgs.push_back("-O2");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002369 else
Daniel Dunbar7ef5ed62009-03-18 23:39:35 +00002370 A->render(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002371 }
2372
Chad Rosier86b82082012-12-12 20:06:31 +00002373 // Don't warn about unused -flto. This can happen when we're preprocessing or
2374 // precompiling.
2375 Args.ClaimAllArgs(options::OPT_flto);
2376
Daniel Dunbar945577c2009-10-29 02:24:45 +00002377 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002378 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2379 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002380 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002381 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002382
2383 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2384 // (-ansi is equivalent to -std=c89).
2385 //
2386 // If a std is supplied, only add -trigraphs if it follows the
2387 // option.
2388 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2389 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002390 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002391 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002392 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002393 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002394 else
2395 Std->render(Args, CmdArgs);
2396
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002397 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2398 options::OPT_trigraphs))
2399 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002400 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002401 } else {
2402 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002403 //
2404 // FIXME: Clang doesn't correctly handle -std= when the input language
2405 // doesn't match. For the time being just ignore this for C++ inputs;
2406 // eventually we want to do all the standard defaulting here instead of
2407 // splitting it between the driver and clang -cc1.
2408 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002409 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2410 "-std=", /*Joined=*/true);
2411 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2412 CmdArgs.push_back("-std=c++11");
2413
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002414 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002415 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002416
Chandler Carruthb009b142011-04-23 06:30:43 +00002417 // Map the bizarre '-Wwrite-strings' flag to a more sensible
2418 // '-fconst-strings'; this better indicates its actual behavior.
2419 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
2420 false)) {
2421 // For perfect compatibility with GCC, we do this even in the presence of
2422 // '-w'. This flag names something other than a warning for GCC.
2423 CmdArgs.push_back("-fconst-strings");
2424 }
2425
Chandler Carruth61fbf622011-04-23 09:27:53 +00002426 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002427 // during C++ compilation, which it is by default. GCC keeps this define even
2428 // in the presence of '-w', match this behavior bug-for-bug.
2429 if (types::isCXX(InputType) &&
2430 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2431 true)) {
2432 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002433 }
2434
Chandler Carruthe0391482010-05-22 02:21:53 +00002435 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2436 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2437 if (Asm->getOption().matches(options::OPT_fasm))
2438 CmdArgs.push_back("-fgnu-keywords");
2439 else
2440 CmdArgs.push_back("-fno-gnu-keywords");
2441 }
2442
Rafael Espindola4cfa7972011-05-02 17:43:32 +00002443 if (ShouldDisableCFI(Args, getToolChain()))
2444 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00002445
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002446 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2447 CmdArgs.push_back("-fno-dwarf-directory-asm");
2448
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002449 // Add in -fdebug-compilation-dir if necessary.
2450 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00002451
Richard Smith9a568822011-11-21 19:36:32 +00002452 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2453 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002454 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002455 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002456 }
2457
Richard Smith9a568822011-11-21 19:36:32 +00002458 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2459 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002460 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00002461 }
2462
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00002463 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2464 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002465 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002466 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002467 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2468 } else
2469 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00002470 }
2471
Nuno Lopes3d6311d2012-05-08 22:10:46 +00002472
Michael J. Spencer929fccd2012-10-22 22:13:48 +00002473 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002474 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00002475
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002476 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2477 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00002478 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002479 }
David Chisnall5778fce2009-08-31 16:41:57 +00002480
Chris Lattnere23003d2010-01-09 21:54:33 +00002481 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2482 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00002483 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00002484 }
2485
Chris Lattnerb35583d2010-04-07 20:49:23 +00002486 CmdArgs.push_back("-ferror-limit");
2487 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00002488 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00002489 else
2490 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00002491
Chandler Carrutha77a7272010-05-06 04:55:18 +00002492 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2493 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002494 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002495 }
2496
2497 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2498 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002499 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002500 }
2501
Richard Smithf6f003a2011-12-16 19:06:07 +00002502 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2503 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002504 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00002505 }
2506
Daniel Dunbar2c978472009-11-04 06:24:47 +00002507 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00002508 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00002509 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002510 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00002511 } else {
2512 // If -fmessage-length=N was not specified, determine whether this is a
2513 // terminal and, if so, implicitly define -fmessage-length appropriately.
2514 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002515 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00002516 }
2517
Daniel Dunbare357d562009-12-03 18:42:11 +00002518 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
2519 CmdArgs.push_back("-fvisibility");
Richard Smithbd55daf2012-11-01 04:30:05 +00002520 CmdArgs.push_back(A->getValue());
Daniel Dunbare357d562009-12-03 18:42:11 +00002521 }
2522
Douglas Gregor08329632010-06-15 17:05:35 +00002523 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002524
Hans Wennborgf60f6af2012-06-28 08:01:44 +00002525 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2526
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002527 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002528 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2529 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002530 CmdArgs.push_back("-ffreestanding");
2531
Daniel Dunbare357d562009-12-03 18:42:11 +00002532 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002533 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002534 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patel91bbb552010-09-30 19:05:55 +00002535 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Devang Patel384dfa42011-11-04 20:05:58 +00002536 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
Eric Christopher86050822011-10-25 07:13:06 +00002537 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Anton Yartsev9b6b2e52011-12-23 20:23:19 +00002538 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00002539 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2540 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00002541
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002542 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00002543 Sanitize.addArgs(Args, CmdArgs);
2544
Will Dietz3676d562012-12-30 20:53:28 +00002545 if (!Args.hasFlag(options::OPT_fsanitize_recover,
2546 options::OPT_fno_sanitize_recover,
2547 true))
2548 CmdArgs.push_back("-fno-sanitize-recover");
2549
Chad Rosierae229d52013-01-29 23:31:22 +00002550 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
2551 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
2552 options::OPT_fno_sanitize_undefined_trap_on_error, false))
2553 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
2554
Chad Rosier864dfe12012-03-13 23:45:51 +00002555 // Report and error for -faltivec on anything other then PowerPC.
2556 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
2557 if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc ||
2558 getToolChain().getTriple().getArch() == llvm::Triple::ppc64))
2559 D.Diag(diag::err_drv_argument_only_allowed_with)
2560 << A->getAsString(Args) << "ppc/ppc64";
2561
Daniel Dunbar733b0f82011-03-01 18:49:30 +00002562 if (getToolChain().SupportsProfiling())
2563 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00002564
2565 // -flax-vector-conversions is default.
2566 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2567 options::OPT_fno_lax_vector_conversions))
2568 CmdArgs.push_back("-fno-lax-vector-conversions");
2569
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002570 if (Args.getLastArg(options::OPT_fapple_kext))
2571 CmdArgs.push_back("-fapple-kext");
2572
David Blaikie690f21e2012-06-14 18:55:27 +00002573 if (Args.hasFlag(options::OPT_frewrite_includes,
2574 options::OPT_fno_rewrite_includes, false))
2575 CmdArgs.push_back("-frewrite-includes");
2576
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00002577 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00002578 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00002579 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002580 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2581 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00002582
2583 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2584 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00002585 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00002586 }
2587
Bob Wilson14adb362012-02-03 06:27:22 +00002588 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00002589
Chandler Carruth6e501032011-03-27 00:04:55 +00002590 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2591 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2592 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2593 options::OPT_fno_wrapv)) {
2594 if (A->getOption().matches(options::OPT_fwrapv))
2595 CmdArgs.push_back("-fwrapv");
2596 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2597 options::OPT_fno_strict_overflow)) {
2598 if (A->getOption().matches(options::OPT_fno_strict_overflow))
2599 CmdArgs.push_back("-fwrapv");
2600 }
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002601 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf387dbd2010-08-07 23:08:14 +00002602 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002603
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00002604 Args.AddLastArg(CmdArgs, options::OPT_pthread);
2605
Mahesha S6a682be42012-10-27 07:47:56 +00002606
Daniel Dunbar4930e332009-11-17 08:07:36 +00002607 // -stack-protector=0 is default.
2608 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002609 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2610 options::OPT_fstack_protector_all,
2611 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002612 if (A->getOption().matches(options::OPT_fstack_protector))
2613 StackProtectorLevel = 1;
2614 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2615 StackProtectorLevel = 2;
Nico Weberdd473632011-08-23 07:38:27 +00002616 } else {
2617 StackProtectorLevel =
2618 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2619 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002620 if (StackProtectorLevel) {
2621 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002622 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002623 }
Chad Rosierdb3da832012-08-21 16:16:06 +00002624
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002625 // --param ssp-buffer-size=
2626 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
2627 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002628 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002629 if (Str.startswith("ssp-buffer-size=")) {
2630 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00002631 CmdArgs.push_back("-stack-protector-buffer-size");
2632 // FIXME: Verify the argument is a valid integer.
2633 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00002634 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002635 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00002636 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002637 }
2638
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00002639 // Translate -mstackrealign
2640 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2641 false)) {
2642 CmdArgs.push_back("-backend-option");
2643 CmdArgs.push_back("-force-align-stack");
2644 }
2645 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2646 false)) {
2647 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2648 }
2649
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00002650 if (Args.hasArg(options::OPT_mstack_alignment)) {
2651 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2652 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00002653 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00002654 // -mkernel implies -mstrict-align; don't add the redundant option.
2655 if (Args.hasArg(options::OPT_mstrict_align) && !KernelOrKext) {
Chad Rosierd87e4f72012-11-09 18:27:01 +00002656 CmdArgs.push_back("-backend-option");
2657 CmdArgs.push_back("-arm-strict-align");
Chad Rosier60027022012-11-09 17:29:19 +00002658 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002659
Daniel Dunbard18049a2009-04-07 21:16:11 +00002660 // Forward -f options with positive and negative forms; we translate
2661 // these by hand.
2662
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002663 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00002664 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002665 CmdArgs.push_back("-fapple-kext");
2666 if (!Args.hasArg(options::OPT_fbuiltin))
2667 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00002668 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002669 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002670 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002671 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00002672 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00002673
Nuno Lopes13c88c72009-12-16 16:59:22 +00002674 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2675 options::OPT_fno_assume_sane_operator_new))
2676 CmdArgs.push_back("-fno-assume-sane-operator-new");
2677
Daniel Dunbar4930e332009-11-17 08:07:36 +00002678 // -fblocks=0 is default.
2679 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00002680 getToolChain().IsBlocksDefault()) ||
2681 (Args.hasArg(options::OPT_fgnu_runtime) &&
2682 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
2683 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002684 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00002685
2686 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
2687 !getToolChain().hasBlocksRuntime())
2688 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00002689 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00002690
Douglas Gregor226173a2012-01-18 15:19:58 +00002691 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
2692 // users must also pass -fcxx-modules. The latter flag will disappear once the
2693 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00002694 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00002695 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
2696 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2697 options::OPT_fno_cxx_modules,
2698 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00002699 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00002700 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00002701 HaveModules = true;
2702 }
2703 }
2704
Douglas Gregor35b04d62013-02-07 19:01:24 +00002705 // If a module path was provided, pass it along. Otherwise, use a temporary
2706 // directory.
2707 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
2708 A->claim();
2709 if (HaveModules) {
2710 A->render(Args, CmdArgs);
2711 }
2712 } else if (HaveModules) {
2713 SmallString<128> DefaultModuleCache;
2714 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
2715 DefaultModuleCache);
2716 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00002717 const char Arg[] = "-fmodules-cache-path=";
2718 DefaultModuleCache.insert(DefaultModuleCache.begin(),
2719 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00002720 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
2721 }
2722
2723 // Pass through all -fmodules-ignore-macro arguments.
2724 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
2725
Douglas Gregorc60437f2013-01-16 01:23:41 +00002726 // -fmodules-autolink (on by default when modules is enabled) automatically
2727 // links against libraries for imported modules.
2728 if (HaveModules &&
2729 Args.hasFlag(options::OPT_fmodules_autolink,
2730 options::OPT_fno_modules_autolink,
2731 true)) {
2732 CmdArgs.push_back("-fmodules-autolink");
Douglas Gregor226173a2012-01-18 15:19:58 +00002733 }
Douglas Gregor787869b2012-01-03 17:13:05 +00002734
John McCalldfea9982010-04-09 19:12:06 +00002735 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00002736 if (Args.hasFlag(options::OPT_fno_access_control,
2737 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00002738 false))
John McCall3155f572010-04-09 19:03:51 +00002739 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00002740
Anders Carlssond470fef2010-11-21 00:09:52 +00002741 // -felide-constructors is the default.
2742 if (Args.hasFlag(options::OPT_fno_elide_constructors,
2743 options::OPT_felide_constructors,
2744 false))
2745 CmdArgs.push_back("-fno-elide-constructors");
2746
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002747 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002748 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00002749 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00002750 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00002751
Richard Smith52be6192012-11-05 22:04:41 +00002752 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002753 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00002754 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00002755 Args.getLastArg(options::OPT_mkernel,
2756 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00002757 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00002758 D.Diag(diag::err_drv_argument_not_allowed_with)
2759 << "-fsanitize=vptr" << NoRttiArg;
2760 }
2761 }
2762
Tony Linthicum76329bf2011-12-12 21:14:55 +00002763 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002764 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00002765 options::OPT_fno_short_enums,
2766 getToolChain().getTriple().getArch() ==
2767 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002768 CmdArgs.push_back("-fshort-enums");
2769
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002770 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002771 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002772 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00002773 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00002774
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002775 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002776 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002777 options::OPT_fno_threadsafe_statics))
2778 CmdArgs.push_back("-fno-threadsafe-statics");
2779
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002780 // -fuse-cxa-atexit is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002781 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
2782 options::OPT_fno_use_cxa_atexit,
2783 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
Tony Linthicum76329bf2011-12-12 21:14:55 +00002784 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Chad Rosier4fab82c2012-03-26 22:04:46 +00002785 getToolChain().getTriple().getArch() != llvm::Triple::hexagon) ||
2786 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002787 CmdArgs.push_back("-fno-use-cxa-atexit");
2788
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002789 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002790 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002791 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2792 CmdArgs.push_back("-fms-extensions");
2793
Francois Pichet1b4f1632011-09-17 04:32:15 +00002794 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00002795 if (Args.hasFlag(options::OPT_fms_compatibility,
2796 options::OPT_fno_ms_compatibility,
2797 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
2798 Args.hasFlag(options::OPT_fms_extensions,
2799 options::OPT_fno_ms_extensions,
2800 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00002801 CmdArgs.push_back("-fms-compatibility");
2802
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002803 // -fmsc-version=1300 is default.
2804 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2805 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
2806 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002807 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002808 if (msc_ver.empty())
2809 CmdArgs.push_back("-fmsc-version=1300");
2810 else
2811 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
2812 }
2813
2814
Dawn Perchik68bb1b42010-09-02 23:59:25 +00002815 // -fborland-extensions=0 is default.
2816 if (Args.hasFlag(options::OPT_fborland_extensions,
2817 options::OPT_fno_borland_extensions, false))
2818 CmdArgs.push_back("-fborland-extensions");
2819
Francois Pichet02744872011-09-01 16:38:08 +00002820 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
2821 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00002822 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
2823 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00002824 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00002825 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00002826
Chandler Carruthe03aa552010-04-17 20:17:31 +00002827 // -fgnu-keywords default varies depending on language; only pass if
2828 // specified.
2829 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00002830 options::OPT_fno_gnu_keywords))
2831 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00002832
Rafael Espindola922a6242011-06-02 17:30:53 +00002833 if (Args.hasFlag(options::OPT_fgnu89_inline,
2834 options::OPT_fno_gnu89_inline,
2835 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00002836 CmdArgs.push_back("-fgnu89-inline");
2837
Chad Rosier9c76d242012-03-15 22:31:42 +00002838 if (Args.hasArg(options::OPT_fno_inline))
2839 CmdArgs.push_back("-fno-inline");
2840
Chad Rosier64d6be92012-03-06 21:17:19 +00002841 if (Args.hasArg(options::OPT_fno_inline_functions))
2842 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00002843
John McCall5fb5df92012-06-20 06:18:46 +00002844 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00002845
John McCall5fb5df92012-06-20 06:18:46 +00002846 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
2847 // legacy is the default.
2848 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00002849 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2850 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00002851 objcRuntime.isLegacyDispatchDefaultForArch(
2852 getToolChain().getTriple().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00002853 if (getToolChain().UseObjCMixedDispatch())
2854 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
2855 else
2856 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
2857 }
2858 }
2859
Nico Weber97bd94b2012-03-09 21:19:44 +00002860 // -fobjc-default-synthesize-properties=1 is default. This only has an effect
2861 // if the nonfragile objc abi is used.
Fariborz Jahanian05684072012-04-09 18:58:55 +00002862 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
David Chisnall3154e682011-09-30 13:32:35 +00002863 CmdArgs.push_back("-fobjc-default-synthesize-properties");
2864 }
2865
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00002866 // -fencode-extended-block-signature=1 is default.
2867 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
2868 CmdArgs.push_back("-fencode-extended-block-signature");
2869 }
2870
John McCall24fc0de2011-07-06 00:26:06 +00002871 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
2872 // NOTE: This logic is duplicated in ToolChains.cpp.
2873 bool ARC = isObjCAutoRefCount(Args);
2874 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00002875 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00002876
John McCall24fc0de2011-07-06 00:26:06 +00002877 CmdArgs.push_back("-fobjc-arc");
2878
Chandler Carruth491db322011-11-04 07:34:47 +00002879 // FIXME: It seems like this entire block, and several around it should be
2880 // wrapped in isObjC, but for now we just use it here as this is where it
2881 // was being used previously.
2882 if (types::isCXX(InputType) && types::isObjC(InputType)) {
2883 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2884 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
2885 else
2886 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
2887 }
2888
John McCall24fc0de2011-07-06 00:26:06 +00002889 // Allow the user to enable full exceptions code emission.
2890 // We define off for Objective-CC, on for Objective-C++.
2891 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2892 options::OPT_fno_objc_arc_exceptions,
2893 /*default*/ types::isCXX(InputType)))
2894 CmdArgs.push_back("-fobjc-arc-exceptions");
2895 }
2896
2897 // -fobjc-infer-related-result-type is the default, except in the Objective-C
2898 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00002899 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00002900 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002901
John McCall24fc0de2011-07-06 00:26:06 +00002902 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
2903 // takes precedence.
2904 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
2905 if (!GCArg)
2906 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
2907 if (GCArg) {
2908 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002909 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00002910 << GCArg->getAsString(Args);
2911 } else if (getToolChain().SupportsObjCGC()) {
2912 GCArg->render(Args, CmdArgs);
2913 } else {
2914 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002915 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00002916 << GCArg->getAsString(Args);
2917 }
2918 }
2919
John McCallb5f652e2011-06-22 00:53:57 +00002920 // Add exception args.
2921 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00002922 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00002923
2924 if (getToolChain().UseSjLjExceptions())
2925 CmdArgs.push_back("-fsjlj-exceptions");
2926
2927 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00002928 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2929 options::OPT_fno_assume_sane_operator_new))
2930 CmdArgs.push_back("-fno-assume-sane-operator-new");
2931
Daniel Dunbar34d7a992010-04-27 15:34:57 +00002932 // -fconstant-cfstrings is default, and may be subject to argument translation
2933 // on Darwin.
2934 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2935 options::OPT_fno_constant_cfstrings) ||
2936 !Args.hasFlag(options::OPT_mconstant_cfstrings,
2937 options::OPT_mno_constant_cfstrings))
2938 CmdArgs.push_back("-fno-constant-cfstrings");
2939
John Thompsoned4e2952009-11-05 20:14:16 +00002940 // -fshort-wchar default varies depending on platform; only
2941 // pass if specified.
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00002942 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2943 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00002944
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +00002945 // -fno-pascal-strings is default, only pass non-default. If the tool chain
2946 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbard4510f22009-04-07 23:51:44 +00002947 //
2948 // FIXME: This is gross; that translation should be pulled from the
2949 // tool chain.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002950 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00002951 options::OPT_fno_pascal_strings,
2952 false) ||
2953 Args.hasFlag(options::OPT_mpascal_strings,
2954 options::OPT_mno_pascal_strings,
2955 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002956 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002957
Daniel Dunbar096ed292011-10-05 21:04:55 +00002958 // Honor -fpack-struct= and -fpack-struct, if given. Note that
2959 // -fno-pack-struct doesn't apply to -fpack-struct=.
2960 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00002961 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00002962 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00002963 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00002964 } else if (Args.hasFlag(options::OPT_fpack_struct,
2965 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00002966 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00002967 }
2968
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002969 if (Args.hasArg(options::OPT_mkernel) ||
2970 Args.hasArg(options::OPT_fapple_kext)) {
2971 if (!Args.hasArg(options::OPT_fcommon))
2972 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00002973 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002974 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00002975
Daniel Dunbard18049a2009-04-07 21:16:11 +00002976 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002977 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002978 CmdArgs.push_back("-fno-common");
2979
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002980 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00002981 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00002982 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002983 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002984 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002985 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2986
Daniel Dunbar6358d682010-10-15 22:30:42 +00002987 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2988 if (!Args.hasFlag(options::OPT_ffor_scope,
2989 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002990 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00002991 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2992
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00002993 // -fcaret-diagnostics is default.
2994 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2995 options::OPT_fno_caret_diagnostics, true))
2996 CmdArgs.push_back("-fno-caret-diagnostics");
2997
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002998 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00002999 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003000 options::OPT_fno_diagnostics_fixit_info))
3001 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003002
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003003 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003004 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003005 options::OPT_fno_diagnostics_show_option))
3006 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003007
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003008 if (const Arg *A =
3009 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3010 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003011 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003012 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003013
Douglas Gregor643c9222011-05-21 17:07:29 +00003014 if (const Arg *A =
3015 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3016 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003017 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003018 }
3019
Chandler Carruthb6766f02011-03-27 01:50:55 +00003020 if (Arg *A = Args.getLastArg(
3021 options::OPT_fdiagnostics_show_note_include_stack,
3022 options::OPT_fno_diagnostics_show_note_include_stack)) {
3023 if (A->getOption().matches(
3024 options::OPT_fdiagnostics_show_note_include_stack))
3025 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3026 else
3027 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3028 }
3029
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003030 // Color diagnostics are the default, unless the terminal doesn't support
3031 // them.
3032 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidis4f920162010-09-23 12:56:06 +00003033 options::OPT_fno_color_diagnostics,
3034 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003035 CmdArgs.push_back("-fcolor-diagnostics");
3036
Daniel Dunbardb097022009-06-08 21:13:54 +00003037 if (!Args.hasFlag(options::OPT_fshow_source_location,
3038 options::OPT_fno_show_source_location))
3039 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003040
Douglas Gregor643c9222011-05-21 17:07:29 +00003041 if (!Args.hasFlag(options::OPT_fshow_column,
3042 options::OPT_fno_show_column,
3043 true))
3044 CmdArgs.push_back("-fno-show-column");
3045
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003046 if (!Args.hasFlag(options::OPT_fspell_checking,
3047 options::OPT_fno_spell_checking))
3048 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003049
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003050
Chad Rosierc8e56e82012-12-05 21:08:21 +00003051 // -fno-asm-blocks is default.
3052 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3053 false))
3054 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003055
Nadav Rotem1cd71a72012-12-18 23:10:16 +00003056 // -fvectorize is default.
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003057 if (Args.hasFlag(options::OPT_fvectorize,
Nadav Rotem1cd71a72012-12-18 23:10:16 +00003058 options::OPT_fno_vectorize, true)) {
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003059 CmdArgs.push_back("-backend-option");
3060 CmdArgs.push_back("-vectorize-loops");
3061 }
3062
Hal Finkel061f1652012-12-11 19:59:32 +00003063 // -fno-slp-vectorize is default.
3064 if (Args.hasFlag(options::OPT_fslp_vectorize,
3065 options::OPT_fno_slp_vectorize, false)) {
3066 CmdArgs.push_back("-backend-option");
3067 CmdArgs.push_back("-vectorize");
3068 }
3069
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00003070 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3071 A->render(Args, CmdArgs);
3072
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003073 // -fdollars-in-identifiers default varies depending on platform and
3074 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003075 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003076 options::OPT_fno_dollars_in_identifiers)) {
3077 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003078 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003079 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003080 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003081 }
3082
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003083 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3084 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003085 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003086 options::OPT_fno_unit_at_a_time)) {
3087 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003088 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003089 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003090
Eli Friedman055c9702011-11-02 01:53:16 +00003091 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3092 options::OPT_fno_apple_pragma_pack, false))
3093 CmdArgs.push_back("-fapple-pragma-pack");
3094
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003095 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003096 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003097 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003098#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00003099 if (getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003100 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3101 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
3102 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3103 CmdArgs.push_back("-fno-builtin-strcat");
3104 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3105 CmdArgs.push_back("-fno-builtin-strcpy");
3106 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003107#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003108
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003109 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00003110 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003111 options::OPT_traditional_cpp)) {
3112 if (isa<PreprocessJobAction>(JA))
3113 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003114 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003115 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003116 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003117
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003118 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00003119 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003120
3121 // Handle serialized diagnostics.
3122 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3123 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003124 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003125 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003126
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003127 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3128 CmdArgs.push_back("-fretain-comments-from-system-headers");
3129
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003130 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3131 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003132 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003133 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3134 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003135 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003136
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003137 // We translate this by hand to the -cc1 argument, since nightly test uses
3138 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003139 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003140 CmdArgs.push_back("-disable-llvm-optzns");
3141 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003142 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003143 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003144
Daniel Dunbard67a3222009-03-30 06:36:42 +00003145 if (Output.getType() == types::TY_Dependencies) {
3146 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003147 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003148 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003149 CmdArgs.push_back(Output.getFilename());
3150 } else {
3151 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003152 }
3153
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003154 for (InputInfoList::const_iterator
3155 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3156 const InputInfo &II = *it;
3157 CmdArgs.push_back("-x");
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00003158 if (Args.hasArg(options::OPT_rewrite_objc))
3159 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3160 else
3161 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbarb440f562010-08-02 02:38:21 +00003162 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003163 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003164 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003165 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003166 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003167
Chris Lattnere9d7d782009-11-03 19:50:27 +00003168 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3169
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003170 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003171
3172 // Optionally embed the -cc1 level arguments into the debug info, for build
3173 // analysis.
3174 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003175 ArgStringList OriginalArgs;
3176 for (ArgList::const_iterator it = Args.begin(),
3177 ie = Args.end(); it != ie; ++it)
3178 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003179
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003180 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003181 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003182 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003183 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003184 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003185 }
3186 CmdArgs.push_back("-dwarf-debug-flags");
3187 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3188 }
3189
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003190 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar17731772009-03-23 19:03:36 +00003191
Roman Divacky178e01602011-02-10 16:52:03 +00003192 if (Arg *A = Args.getLastArg(options::OPT_pg))
3193 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003194 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003195 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003196
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003197 // Claim some arguments which clang supports automatically.
3198
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003199 // -fpch-preprocess is used with gcc to add a special marker in the output to
3200 // include the PCH file. Clang's PTH solution is completely transparent, so we
3201 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003202 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003203
Daniel Dunbar17731772009-03-23 19:03:36 +00003204 // Claim some arguments which clang doesn't support, but we don't
3205 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003206 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3207 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003208
Rafael Espindolad95a8122011-03-01 05:25:27 +00003209 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
Rafael Espindola22f603032011-02-28 23:29:45 +00003210 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003211 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003212}
3213
Jim Grosbach576452b2012-02-10 20:37:10 +00003214void ClangAs::AddARMTargetArgs(const ArgList &Args,
3215 ArgStringList &CmdArgs) const {
3216 const Driver &D = getToolChain().getDriver();
3217 llvm::Triple Triple = getToolChain().getTriple();
3218
3219 // Set the CPU based on -march= and -mcpu=.
3220 CmdArgs.push_back("-target-cpu");
Benjamin Kramer09811c72012-06-26 22:20:06 +00003221 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
Jim Grosbach576452b2012-02-10 20:37:10 +00003222
3223 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +00003224 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +00003225 addFPUArgs(D, A, Args, CmdArgs);
Chad Rosier1f0e52e2012-04-04 20:39:32 +00003226
3227 // Honor -mfpmath=.
3228 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +00003229 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Jim Grosbach576452b2012-02-10 20:37:10 +00003230}
3231
John McCall5fb5df92012-06-20 06:18:46 +00003232/// Add options related to the Objective-C runtime/ABI.
3233///
3234/// Returns true if the runtime is non-fragile.
3235ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3236 ArgStringList &cmdArgs,
3237 RewriteKind rewriteKind) const {
3238 // Look for the controlling runtime option.
3239 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3240 options::OPT_fgnu_runtime,
3241 options::OPT_fobjc_runtime_EQ);
3242
3243 // Just forward -fobjc-runtime= to the frontend. This supercedes
3244 // options about fragility.
3245 if (runtimeArg &&
3246 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3247 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003248 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003249 if (runtime.tryParse(value)) {
3250 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3251 << value;
3252 }
3253
3254 runtimeArg->render(args, cmdArgs);
3255 return runtime;
3256 }
3257
3258 // Otherwise, we'll need the ABI "version". Version numbers are
3259 // slightly confusing for historical reasons:
3260 // 1 - Traditional "fragile" ABI
3261 // 2 - Non-fragile ABI, version 1
3262 // 3 - Non-fragile ABI, version 2
3263 unsigned objcABIVersion = 1;
3264 // If -fobjc-abi-version= is present, use that to set the version.
3265 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003266 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003267 if (value == "1")
3268 objcABIVersion = 1;
3269 else if (value == "2")
3270 objcABIVersion = 2;
3271 else if (value == "3")
3272 objcABIVersion = 3;
3273 else
3274 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3275 << value;
3276 } else {
3277 // Otherwise, determine if we are using the non-fragile ABI.
3278 bool nonFragileABIIsDefault =
3279 (rewriteKind == RK_NonFragile ||
3280 (rewriteKind == RK_None &&
3281 getToolChain().IsObjCNonFragileABIDefault()));
3282 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3283 options::OPT_fno_objc_nonfragile_abi,
3284 nonFragileABIIsDefault)) {
3285 // Determine the non-fragile ABI version to use.
3286#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3287 unsigned nonFragileABIVersion = 1;
3288#else
3289 unsigned nonFragileABIVersion = 2;
3290#endif
3291
3292 if (Arg *abiArg = args.getLastArg(
3293 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003294 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003295 if (value == "1")
3296 nonFragileABIVersion = 1;
3297 else if (value == "2")
3298 nonFragileABIVersion = 2;
3299 else
3300 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3301 << value;
3302 }
3303
3304 objcABIVersion = 1 + nonFragileABIVersion;
3305 } else {
3306 objcABIVersion = 1;
3307 }
3308 }
3309
3310 // We don't actually care about the ABI version other than whether
3311 // it's non-fragile.
3312 bool isNonFragile = objcABIVersion != 1;
3313
3314 // If we have no runtime argument, ask the toolchain for its default runtime.
3315 // However, the rewriter only really supports the Mac runtime, so assume that.
3316 ObjCRuntime runtime;
3317 if (!runtimeArg) {
3318 switch (rewriteKind) {
3319 case RK_None:
3320 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3321 break;
3322 case RK_Fragile:
3323 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3324 break;
3325 case RK_NonFragile:
3326 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3327 break;
3328 }
3329
3330 // -fnext-runtime
3331 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3332 // On Darwin, make this use the default behavior for the toolchain.
3333 if (getToolChain().getTriple().isOSDarwin()) {
3334 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3335
3336 // Otherwise, build for a generic macosx port.
3337 } else {
3338 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3339 }
3340
3341 // -fgnu-runtime
3342 } else {
3343 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00003344 // Legacy behaviour is to target the gnustep runtime if we are i
3345 // non-fragile mode or the GCC runtime in fragile mode.
3346 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00003347 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00003348 else
3349 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00003350 }
3351
3352 cmdArgs.push_back(args.MakeArgString(
3353 "-fobjc-runtime=" + runtime.getAsString()));
3354 return runtime;
3355}
3356
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003357void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003358 const InputInfo &Output,
3359 const InputInfoList &Inputs,
3360 const ArgList &Args,
3361 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003362 ArgStringList CmdArgs;
3363
3364 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3365 const InputInfo &Input = Inputs[0];
3366
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003367 // Don't warn about "clang -w -c foo.s"
3368 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003369 // and "clang -emit-llvm -c foo.s"
3370 Args.ClaimAllArgs(options::OPT_emit_llvm);
3371 // and "clang -use-gold-plugin -c foo.s"
3372 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003373
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003374 // Invoke ourselves in -cc1as mode.
3375 //
3376 // FIXME: Implement custom jobs for internal actions.
3377 CmdArgs.push_back("-cc1as");
3378
3379 // Add the "effective" target triple.
3380 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00003381 std::string TripleStr =
3382 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003383 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3384
3385 // Set the output mode, we currently only expect to be used as a real
3386 // assembler.
3387 CmdArgs.push_back("-filetype");
3388 CmdArgs.push_back("obj");
3389
Eric Christopher45f2e712012-12-18 00:31:10 +00003390 // Set the main file name, so that debug info works even with
3391 // -save-temps or preprocessed assembly.
3392 CmdArgs.push_back("-main-file-name");
3393 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
3394
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00003395 if (UseRelaxAll(C, Args))
Daniel Dunbar99ca8b72010-05-28 16:43:21 +00003396 CmdArgs.push_back("-relax-all");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003397
Jim Grosbach576452b2012-02-10 20:37:10 +00003398 // Add target specific cpu and features flags.
3399 switch(getToolChain().getTriple().getArch()) {
3400 default:
3401 break;
3402
3403 case llvm::Triple::arm:
3404 case llvm::Triple::thumb:
3405 AddARMTargetArgs(Args, CmdArgs);
3406 break;
3407 }
3408
Daniel Dunbar1d733e22011-03-17 17:37:29 +00003409 // Ignore explicit -force_cpusubtype_ALL option.
3410 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003411
Eric Christopherfc3ee562012-01-10 00:38:01 +00003412 // Determine the original source input.
3413 const Action *SourceAction = &JA;
3414 while (SourceAction->getKind() != Action::InputClass) {
3415 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3416 SourceAction = SourceAction->getInputs()[0];
3417 }
3418
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003419 // Forward -g and handle debug info related flags, assuming we are dealing
3420 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00003421 if (SourceAction->getType() == types::TY_Asm ||
3422 SourceAction->getType() == types::TY_PP_Asm) {
3423 Args.ClaimAllArgs(options::OPT_g_Group);
3424 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3425 if (!A->getOption().matches(options::OPT_g0))
3426 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003427
3428 // Add the -fdebug-compilation-dir flag if needed.
3429 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00003430
3431 // Set the AT_producer to the clang version when using the integrated
3432 // assembler on assembly source files.
3433 CmdArgs.push_back("-dwarf-debug-producer");
3434 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00003435 }
Kevin Enderby292dc082011-12-22 19:31:58 +00003436
3437 // Optionally embed the -cc1as level arguments into the debug info, for build
3438 // analysis.
3439 if (getToolChain().UseDwarfDebugFlags()) {
3440 ArgStringList OriginalArgs;
3441 for (ArgList::const_iterator it = Args.begin(),
3442 ie = Args.end(); it != ie; ++it)
3443 (*it)->render(Args, OriginalArgs);
3444
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003445 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00003446 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3447 Flags += Exec;
3448 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3449 Flags += " ";
3450 Flags += OriginalArgs[i];
3451 }
3452 CmdArgs.push_back("-dwarf-debug-flags");
3453 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3454 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003455
3456 // FIXME: Add -static support, once we have it.
3457
3458 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3459 options::OPT_Xassembler);
Daniel Dunbar252e8f92011-04-29 17:53:18 +00003460 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003461
3462 assert(Output.isFilename() && "Unexpected lipo output.");
3463 CmdArgs.push_back("-o");
3464 CmdArgs.push_back(Output.getFilename());
3465
Daniel Dunbarb440f562010-08-02 02:38:21 +00003466 assert(Input.isFilename() && "Invalid input.");
3467 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003468
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003469 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003470 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003471}
3472
Daniel Dunbara3246a02009-03-18 08:07:30 +00003473void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003474 const InputInfo &Output,
3475 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003476 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003477 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003478 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003479 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003480
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003481 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003482 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003483 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00003484 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00003485 // Don't forward any -g arguments to assembly steps.
3486 if (isa<AssembleJobAction>(JA) &&
3487 A->getOption().matches(options::OPT_g_Group))
3488 continue;
3489
Daniel Dunbar2da02722009-03-19 07:55:12 +00003490 // It is unfortunate that we have to claim here, as this means
3491 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00003492 // platforms using a generic gcc, even if we are just using gcc
3493 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00003494 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003495 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00003496 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003497 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003498
Daniel Dunbar4e295052010-01-25 22:35:08 +00003499 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003500
3501 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003502 llvm::Triple::ArchType Arch = getToolChain().getArch();
Bob Wilson6524dd32011-10-14 05:03:44 +00003503 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003504 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00003505
3506 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003507 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003508 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003509 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003510 CmdArgs.push_back("ppc64");
3511 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003512 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00003513 }
3514
Daniel Dunbar5716d872009-05-02 21:41:52 +00003515 // Try to force gcc to match the tool chain we want, if we recognize
3516 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003517 //
3518 // FIXME: The triple class should directly provide the information we want
3519 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003520 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003521 CmdArgs.push_back("-m32");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003522 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86_64)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003523 CmdArgs.push_back("-m64");
3524
Daniel Dunbarb440f562010-08-02 02:38:21 +00003525 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003526 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003527 CmdArgs.push_back(Output.getFilename());
3528 } else {
3529 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003530 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003531 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003532
Tony Linthicum76329bf2011-12-12 21:14:55 +00003533 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3534 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003535
3536 // Only pass -x if gcc will understand it; otherwise hope gcc
3537 // understands the suffix correctly. The main use case this would go
3538 // wrong in is for linker inputs if they happened to have an odd
3539 // suffix; really the only way to get this to happen is a command
3540 // like '-x foobar a.c' which will treat a.c like a linker input.
3541 //
3542 // FIXME: For the linker case specifically, can we safely convert
3543 // inputs into '-Wl,' options?
3544 for (InputInfoList::const_iterator
3545 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3546 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003547
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003548 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003549 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3550 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003551 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003552 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003553 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003554 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003555 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003556
Daniel Dunbara3246a02009-03-18 08:07:30 +00003557 if (types::canTypeBeUserSpecified(II.getType())) {
3558 CmdArgs.push_back("-x");
3559 CmdArgs.push_back(types::getTypeName(II.getType()));
3560 }
3561
Daniel Dunbarb440f562010-08-02 02:38:21 +00003562 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003563 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00003564 else {
3565 const Arg &A = II.getInputArg();
3566
3567 // Reverse translate some rewritten options.
3568 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
3569 CmdArgs.push_back("-lstdc++");
3570 continue;
3571 }
3572
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003573 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00003574 A.render(Args, CmdArgs);
3575 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003576 }
3577
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003578 const std::string customGCCName = D.getCCCGenericGCCName();
3579 const char *GCCName;
3580 if (!customGCCName.empty())
3581 GCCName = customGCCName.c_str();
3582 else if (D.CCCIsCXX) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003583 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003584 } else
3585 GCCName = "gcc";
3586
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003587 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003588 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003589 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003590}
3591
Daniel Dunbar4e295052010-01-25 22:35:08 +00003592void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
3593 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003594 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003595}
3596
Daniel Dunbar4e295052010-01-25 22:35:08 +00003597void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
3598 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003599 // The type is good enough.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003600}
3601
Daniel Dunbar4e295052010-01-25 22:35:08 +00003602void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
3603 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003604 const Driver &D = getToolChain().getDriver();
3605
Daniel Dunbar4e295052010-01-25 22:35:08 +00003606 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003607 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
3608 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00003609 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003610 else {
3611 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003612 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003613 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003614
Daniel Dunbar4e295052010-01-25 22:35:08 +00003615 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003616 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003617}
3618
Daniel Dunbar4e295052010-01-25 22:35:08 +00003619void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
3620 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003621 CmdArgs.push_back("-c");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003622}
Daniel Dunbara3246a02009-03-18 08:07:30 +00003623
Daniel Dunbar4e295052010-01-25 22:35:08 +00003624void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
3625 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003626 // The types are (hopefully) good enough.
3627}
3628
Tony Linthicum76329bf2011-12-12 21:14:55 +00003629// Hexagon tools start.
3630void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
3631 ArgStringList &CmdArgs) const {
3632
3633}
3634void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3635 const InputInfo &Output,
3636 const InputInfoList &Inputs,
3637 const ArgList &Args,
3638 const char *LinkingOutput) const {
3639
3640 const Driver &D = getToolChain().getDriver();
3641 ArgStringList CmdArgs;
3642
3643 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00003644 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00003645 CmdArgs.push_back(Args.MakeArgString(MarchString));
3646
3647 RenderExtraToolArgs(JA, CmdArgs);
3648
3649 if (Output.isFilename()) {
3650 CmdArgs.push_back("-o");
3651 CmdArgs.push_back(Output.getFilename());
3652 } else {
3653 assert(Output.isNothing() && "Unexpected output");
3654 CmdArgs.push_back("-fsyntax-only");
3655 }
3656
Matthew Curtise8f80a12012-12-06 17:49:03 +00003657 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
3658 if (!SmallDataThreshold.empty())
3659 CmdArgs.push_back(
3660 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00003661
Matthew Curtise5df3812012-12-07 17:23:04 +00003662 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
3663 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3664 options::OPT_Xassembler);
3665
Tony Linthicum76329bf2011-12-12 21:14:55 +00003666 // Only pass -x if gcc will understand it; otherwise hope gcc
3667 // understands the suffix correctly. The main use case this would go
3668 // wrong in is for linker inputs if they happened to have an odd
3669 // suffix; really the only way to get this to happen is a command
3670 // like '-x foobar a.c' which will treat a.c like a linker input.
3671 //
3672 // FIXME: For the linker case specifically, can we safely convert
3673 // inputs into '-Wl,' options?
3674 for (InputInfoList::const_iterator
3675 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3676 const InputInfo &II = *it;
3677
3678 // Don't try to pass LLVM or AST inputs to a generic gcc.
3679 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3680 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3681 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3682 << getToolChain().getTripleString();
3683 else if (II.getType() == types::TY_AST)
3684 D.Diag(clang::diag::err_drv_no_ast_support)
3685 << getToolChain().getTripleString();
3686
3687 if (II.isFilename())
3688 CmdArgs.push_back(II.getFilename());
3689 else
3690 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3691 II.getInputArg().render(Args, CmdArgs);
3692 }
3693
3694 const char *GCCName = "hexagon-as";
3695 const char *Exec =
3696 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3697 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3698
3699}
3700void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
3701 ArgStringList &CmdArgs) const {
3702 // The types are (hopefully) good enough.
3703}
3704
3705void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
3706 const InputInfo &Output,
3707 const InputInfoList &Inputs,
3708 const ArgList &Args,
3709 const char *LinkingOutput) const {
3710
Matthew Curtise689b052012-12-06 15:46:07 +00003711 const toolchains::Hexagon_TC& ToolChain =
3712 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
3713 const Driver &D = ToolChain.getDriver();
3714
Tony Linthicum76329bf2011-12-12 21:14:55 +00003715 ArgStringList CmdArgs;
3716
Matthew Curtise689b052012-12-06 15:46:07 +00003717 //----------------------------------------------------------------------------
3718 //
3719 //----------------------------------------------------------------------------
3720 bool hasStaticArg = Args.hasArg(options::OPT_static);
3721 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00003722 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00003723 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
3724 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
3725 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
3726 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003727
Matthew Curtise689b052012-12-06 15:46:07 +00003728 //----------------------------------------------------------------------------
3729 // Silence warnings for various options
3730 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00003731
Matthew Curtise689b052012-12-06 15:46:07 +00003732 Args.ClaimAllArgs(options::OPT_g_Group);
3733 Args.ClaimAllArgs(options::OPT_emit_llvm);
3734 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
3735 // handled somewhere else.
3736 Args.ClaimAllArgs(options::OPT_static_libgcc);
3737
3738 //----------------------------------------------------------------------------
3739 //
3740 //----------------------------------------------------------------------------
3741 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
3742 e = ToolChain.ExtraOpts.end();
3743 i != e; ++i)
3744 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00003745
Matthew Curtisf10a5952012-12-06 14:16:43 +00003746 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
3747 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00003748
Matthew Curtise689b052012-12-06 15:46:07 +00003749 if (buildingLib) {
3750 CmdArgs.push_back("-shared");
3751 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
3752 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00003753 }
3754
Matthew Curtise689b052012-12-06 15:46:07 +00003755 if (hasStaticArg)
3756 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00003757
Matthew Curtise8f80a12012-12-06 17:49:03 +00003758 if (buildPIE && !buildingLib)
3759 CmdArgs.push_back("-pie");
3760
3761 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
3762 if (!SmallDataThreshold.empty()) {
3763 CmdArgs.push_back(
3764 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
3765 }
3766
Matthew Curtise689b052012-12-06 15:46:07 +00003767 //----------------------------------------------------------------------------
3768 //
3769 //----------------------------------------------------------------------------
3770 CmdArgs.push_back("-o");
3771 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00003772
Matthew Curtise689b052012-12-06 15:46:07 +00003773 const std::string MarchSuffix = "/" + MarchString;
3774 const std::string G0Suffix = "/G0";
3775 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
3776 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
3777 + "/";
3778 const std::string StartFilesDir = RootDir
3779 + "hexagon/lib"
3780 + (buildingLib
3781 ? MarchG0Suffix : MarchSuffix);
3782
3783 //----------------------------------------------------------------------------
3784 // moslib
3785 //----------------------------------------------------------------------------
3786 std::vector<std::string> oslibs;
3787 bool hasStandalone= false;
3788
3789 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
3790 ie = Args.filtered_end(); it != ie; ++it) {
3791 (*it)->claim();
3792 oslibs.push_back((*it)->getValue());
3793 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00003794 }
Matthew Curtise689b052012-12-06 15:46:07 +00003795 if (oslibs.empty()) {
3796 oslibs.push_back("standalone");
3797 hasStandalone = true;
3798 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00003799
Matthew Curtise689b052012-12-06 15:46:07 +00003800 //----------------------------------------------------------------------------
3801 // Start Files
3802 //----------------------------------------------------------------------------
3803 if (incStdLib && incStartFiles) {
3804
3805 if (!buildingLib) {
3806 if (hasStandalone) {
3807 CmdArgs.push_back(
3808 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
3809 }
3810 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
3811 }
3812 std::string initObj = useShared ? "/initS.o" : "/init.o";
3813 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
3814 }
3815
3816 //----------------------------------------------------------------------------
3817 // Library Search Paths
3818 //----------------------------------------------------------------------------
3819 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
3820 for (ToolChain::path_list::const_iterator
3821 i = LibPaths.begin(),
3822 e = LibPaths.end();
3823 i != e;
3824 ++i)
3825 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
3826
3827 //----------------------------------------------------------------------------
3828 //
3829 //----------------------------------------------------------------------------
3830 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3831 Args.AddAllArgs(CmdArgs, options::OPT_e);
3832 Args.AddAllArgs(CmdArgs, options::OPT_s);
3833 Args.AddAllArgs(CmdArgs, options::OPT_t);
3834 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
3835
3836 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
3837
3838 //----------------------------------------------------------------------------
3839 // Libraries
3840 //----------------------------------------------------------------------------
3841 if (incStdLib && incDefLibs) {
3842 if (D.CCCIsCXX) {
3843 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
3844 CmdArgs.push_back("-lm");
3845 }
3846
3847 CmdArgs.push_back("--start-group");
3848
3849 if (!buildingLib) {
3850 for(std::vector<std::string>::iterator i = oslibs.begin(),
3851 e = oslibs.end(); i != e; ++i)
3852 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
3853 CmdArgs.push_back("-lc");
3854 }
3855 CmdArgs.push_back("-lgcc");
3856
3857 CmdArgs.push_back("--end-group");
3858 }
3859
3860 //----------------------------------------------------------------------------
3861 // End files
3862 //----------------------------------------------------------------------------
3863 if (incStdLib && incStartFiles) {
3864 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
3865 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
3866 }
3867
3868 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
3869 C.addCommand(
3870 new Command(
3871 JA, *this,
3872 Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00003873}
3874// Hexagon tools end.
3875
Rafael Espindoladcbf6982012-10-31 18:51:07 +00003876llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
3877 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
3878 // archs which Darwin doesn't use.
3879
3880 // The matching this routine does is fairly pointless, since it is neither the
3881 // complete architecture list, nor a reasonable subset. The problem is that
3882 // historically the driver driver accepts this and also ties its -march=
3883 // handling to the architecture name, so we need to be careful before removing
3884 // support for it.
3885
3886 // This code must be kept in sync with Clang's Darwin specific argument
3887 // translation.
3888
3889 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
3890 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
3891 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
3892 .Case("ppc64", llvm::Triple::ppc64)
3893 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
3894 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
3895 llvm::Triple::x86)
3896 .Case("x86_64", llvm::Triple::x86_64)
3897 // This is derived from the driver driver.
3898 .Cases("arm", "armv4t", "armv5", "armv6", llvm::Triple::arm)
3899 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", llvm::Triple::arm)
3900 .Case("r600", llvm::Triple::r600)
3901 .Case("nvptx", llvm::Triple::nvptx)
3902 .Case("nvptx64", llvm::Triple::nvptx64)
3903 .Case("amdil", llvm::Triple::amdil)
3904 .Case("spir", llvm::Triple::spir)
3905 .Default(llvm::Triple::UnknownArch);
3906}
Tony Linthicum76329bf2011-12-12 21:14:55 +00003907
Bob Wilsondecc03e2012-11-23 06:14:39 +00003908const char *Clang::getBaseInputName(const ArgList &Args,
3909 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00003910 return Args.MakeArgString(
3911 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003912}
3913
Bob Wilsondecc03e2012-11-23 06:14:39 +00003914const char *Clang::getBaseInputStem(const ArgList &Args,
3915 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003916 const char *Str = getBaseInputName(Args, Inputs);
3917
Chris Lattner906bb902011-01-16 08:14:11 +00003918 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003919 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003920
3921 return Str;
3922}
3923
Bob Wilsondecc03e2012-11-23 06:14:39 +00003924const char *Clang::getDependencyFileName(const ArgList &Args,
3925 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003926 // FIXME: Think about this more.
3927 std::string Res;
3928
3929 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003930 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003931 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003932 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00003933 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003934 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003935 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003936}
3937
Daniel Dunbarbe220842009-03-20 16:06:39 +00003938void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003939 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003940 const InputInfoList &Inputs,
3941 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00003942 const char *LinkingOutput) const {
3943 ArgStringList CmdArgs;
3944
3945 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3946 const InputInfo &Input = Inputs[0];
3947
Daniel Dunbardc8355e2011-04-12 23:59:20 +00003948 // Determine the original source input.
3949 const Action *SourceAction = &JA;
3950 while (SourceAction->getKind() != Action::InputClass) {
3951 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3952 SourceAction = SourceAction->getInputs()[0];
3953 }
3954
3955 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00003956 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00003957 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00003958 if (Args.hasArg(options::OPT_gstabs))
3959 CmdArgs.push_back("--gstabs");
3960 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00003961 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00003962 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003963
Daniel Dunbarbe220842009-03-20 16:06:39 +00003964 // Derived from asm spec.
Daniel Dunbar3571dd92009-09-09 18:36:27 +00003965 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00003966
Daniel Dunbar6d484762010-07-22 01:47:22 +00003967 // Use -force_cpusubtype_ALL on x86 by default.
3968 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
3969 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00003970 Args.hasArg(options::OPT_force__cpusubtype__ALL))
3971 CmdArgs.push_back("-force_cpusubtype_ALL");
3972
Daniel Dunbara6b4a3d2009-08-24 22:26:16 +00003973 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00003974 (((Args.hasArg(options::OPT_mkernel) ||
3975 Args.hasArg(options::OPT_fapple_kext)) &&
3976 (!getDarwinToolChain().isTargetIPhoneOS() ||
3977 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
3978 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003979 CmdArgs.push_back("-static");
3980
Daniel Dunbarbe220842009-03-20 16:06:39 +00003981 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3982 options::OPT_Xassembler);
3983
3984 assert(Output.isFilename() && "Unexpected lipo output.");
3985 CmdArgs.push_back("-o");
3986 CmdArgs.push_back(Output.getFilename());
3987
Daniel Dunbarb440f562010-08-02 02:38:21 +00003988 assert(Input.isFilename() && "Invalid input.");
3989 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00003990
3991 // asm_final spec is empty.
3992
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003993 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003994 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003995 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00003996}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00003997
David Blaikie68e081d2011-12-20 02:48:34 +00003998void darwin::DarwinTool::anchor() {}
3999
Daniel Dunbare9ded432009-09-09 18:36:20 +00004000void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4001 ArgStringList &CmdArgs) const {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004002 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00004003
Daniel Dunbarc1964212009-03-26 16:23:12 +00004004 // Derived from darwin_arch spec.
4005 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00004006 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00004007
Daniel Dunbardcc3b652010-01-22 02:04:58 +00004008 // FIXME: Is this needed anymore?
4009 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00004010 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00004011}
4012
Bill Wendling3b2000f2012-10-02 18:02:50 +00004013bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4014 // We only need to generate a temp path for LTO if we aren't compiling object
4015 // files. When compiling source files, we run 'dsymutil' after linking. We
4016 // don't run 'dsymutil' when compiling object files.
4017 for (InputInfoList::const_iterator
4018 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4019 if (it->getType() != types::TY_Object)
4020 return true;
4021
4022 return false;
4023}
4024
Daniel Dunbarccbc4522010-09-09 21:51:05 +00004025void darwin::Link::AddLinkArgs(Compilation &C,
4026 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00004027 ArgStringList &CmdArgs,
4028 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004029 const Driver &D = getToolChain().getDriver();
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004030 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00004031
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004032 unsigned Version[3] = { 0, 0, 0 };
4033 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4034 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00004035 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004036 Version[1], Version[2], HadExtra) ||
4037 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004038 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004039 << A->getAsString(Args);
4040 }
4041
4042 // Newer linkers support -demangle, pass it if supported and not disabled by
4043 // the user.
Daniel Dunbarecb41cb2012-01-04 21:45:27 +00004044 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00004045 // Don't pass -demangle to ld_classic.
4046 //
4047 // FIXME: This is a temporary workaround, ld should be handling this.
4048 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4049 Args.hasArg(options::OPT_static));
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00004050 if (getToolChain().getArch() == llvm::Triple::x86) {
4051 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4052 options::OPT_Wl_COMMA),
4053 ie = Args.filtered_end(); it != ie; ++it) {
4054 const Arg *A = *it;
4055 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Richard Smithbd55daf2012-11-01 04:30:05 +00004056 if (StringRef(A->getValue(i)) == "-kext")
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00004057 UsesLdClassic = true;
4058 }
4059 }
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00004060 if (!UsesLdClassic)
4061 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004062 }
4063
Bill Wendling313b6bf2012-11-16 23:03:00 +00004064 // If we are using LTO, then automatically create a temporary file path for
4065 // the linker to use, so that it's lifetime will extend past a possible
4066 // dsymutil step.
4067 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4068 const char *TmpPath = C.getArgs().MakeArgString(
4069 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4070 C.addTempFile(TmpPath);
4071 CmdArgs.push_back("-object_path_lto");
4072 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00004073 }
4074
Daniel Dunbarc1964212009-03-26 16:23:12 +00004075 // Derived from the "link" spec.
4076 Args.AddAllArgs(CmdArgs, options::OPT_static);
4077 if (!Args.hasArg(options::OPT_static))
4078 CmdArgs.push_back("-dynamic");
4079 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4080 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4081 // here. How do we wish to handle such things?
4082 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004083
Daniel Dunbarc1964212009-03-26 16:23:12 +00004084 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara48823f2010-01-22 02:04:52 +00004085 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00004086 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00004087 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004088
4089 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4090 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4091 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4092
4093 Arg *A;
4094 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4095 (A = Args.getLastArg(options::OPT_current__version)) ||
4096 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004097 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00004098 << A->getAsString(Args) << "-dynamiclib";
4099
4100 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4101 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4102 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4103 } else {
4104 CmdArgs.push_back("-dylib");
4105
4106 Arg *A;
4107 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4108 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4109 (A = Args.getLastArg(options::OPT_client__name)) ||
4110 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4111 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4112 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004113 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00004114 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004115
Daniel Dunbarc1964212009-03-26 16:23:12 +00004116 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4117 "-dylib_compatibility_version");
4118 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4119 "-dylib_current_version");
4120
Daniel Dunbara48823f2010-01-22 02:04:52 +00004121 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004122
4123 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4124 "-dylib_install_name");
4125 }
4126
4127 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4128 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4129 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004130 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004131 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004132 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4133 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4134 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4135 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4136 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4137 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00004138 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004139 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4140 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4141 Args.AddAllArgs(CmdArgs, options::OPT_init);
4142
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004143 // Add the deployment target.
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00004144 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
Daniel Dunbar72ceb922011-04-30 04:22:58 +00004145
4146 // If we had an explicit -mios-simulator-version-min argument, honor that,
4147 // otherwise use the traditional deployment targets. We can't just check the
4148 // is-sim attribute because existing code follows this path, and the linker
4149 // may not handle the argument.
4150 //
4151 // FIXME: We may be able to remove this, once we can verify no one depends on
4152 // it.
4153 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4154 CmdArgs.push_back("-ios_simulator_version_min");
4155 else if (DarwinTC.isTargetIPhoneOS())
4156 CmdArgs.push_back("-iphoneos_version_min");
4157 else
4158 CmdArgs.push_back("-macosx_version_min");
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00004159 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004160
Daniel Dunbarc1964212009-03-26 16:23:12 +00004161 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4162 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4163 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4164 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4165 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004166
Daniel Dunbaraf68a882010-07-13 23:31:40 +00004167 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4168 options::OPT_fno_pie,
4169 options::OPT_fno_PIE)) {
4170 if (A->getOption().matches(options::OPT_fpie) ||
4171 A->getOption().matches(options::OPT_fPIE))
4172 CmdArgs.push_back("-pie");
4173 else
4174 CmdArgs.push_back("-no_pie");
4175 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004176
4177 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4178 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4179 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4180 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4181 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4182 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4183 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4184 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4185 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4186 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4187 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4188 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4189 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4190 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4191 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4192 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004193
Daniel Dunbar84384642011-05-02 21:03:47 +00004194 // Give --sysroot= preference, over the Apple specific behavior to also use
4195 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00004196 StringRef sysroot = C.getSysRoot();
4197 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00004198 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00004199 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00004200 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4201 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00004202 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004203 }
4204
Daniel Dunbarc1964212009-03-26 16:23:12 +00004205 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4206 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4207 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4208 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4209 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004210 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004211 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4212 Args.AddAllArgs(CmdArgs, options::OPT_y);
4213 Args.AddLastArg(CmdArgs, options::OPT_w);
4214 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4215 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4216 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4217 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4218 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4219 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4220 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4221 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4222 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4223 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4224 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4225 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4226}
4227
4228void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004229 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004230 const InputInfoList &Inputs,
4231 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00004232 const char *LinkingOutput) const {
4233 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00004234
Daniel Dunbarc1964212009-03-26 16:23:12 +00004235 // The logic here is derived from gcc's behavior; most of which
4236 // comes from specs (starting with link_command). Consult gcc for
4237 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00004238 ArgStringList CmdArgs;
4239
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00004240 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4241 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4242 options::OPT_ccc_arcmt_migrate)) {
4243 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4244 (*I)->claim();
4245 const char *Exec =
4246 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4247 CmdArgs.push_back(Output.getFilename());
4248 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4249 return;
4250 }
4251
Daniel Dunbarc1964212009-03-26 16:23:12 +00004252 // I'm not sure why this particular decomposition exists in gcc, but
4253 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00004254 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004255
Daniel Dunbarc1964212009-03-26 16:23:12 +00004256 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4257 Args.AddAllArgs(CmdArgs, options::OPT_s);
4258 Args.AddAllArgs(CmdArgs, options::OPT_t);
4259 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4260 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004261 Args.AddLastArg(CmdArgs, options::OPT_e);
4262 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4263 Args.AddAllArgs(CmdArgs, options::OPT_r);
4264
Daniel Dunbar767bbab2010-10-18 22:08:36 +00004265 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4266 // members of static archive libraries which implement Objective-C classes or
4267 // categories.
4268 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4269 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004270
Bill Wendling58979742012-12-10 21:48:41 +00004271 if (Args.hasArg(options::OPT_rdynamic))
4272 CmdArgs.push_back("-export_dynamic");
4273
Daniel Dunbarc1964212009-03-26 16:23:12 +00004274 CmdArgs.push_back("-o");
4275 CmdArgs.push_back(Output.getFilename());
4276
Chad Rosier06fd3c62012-05-16 23:45:12 +00004277 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004278 !Args.hasArg(options::OPT_nostartfiles)) {
4279 // Derived from startfile spec.
4280 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004281 // Derived from darwin_dylib1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004282 if (getDarwinToolChain().isTargetIOSSimulator()) {
4283 // The simulator doesn't have a versioned crt1 file.
4284 CmdArgs.push_back("-ldylib1.o");
4285 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004286 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4287 CmdArgs.push_back("-ldylib1.o");
4288 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004289 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbar83608032010-01-27 00:56:56 +00004290 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004291 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004292 CmdArgs.push_back("-ldylib1.10.5.o");
4293 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004294 } else {
4295 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004296 if (!Args.hasArg(options::OPT_static)) {
4297 // Derived from darwin_bundle1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004298 if (getDarwinToolChain().isTargetIOSSimulator()) {
4299 // The simulator doesn't have a versioned crt1 file.
4300 CmdArgs.push_back("-lbundle1.o");
4301 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004302 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4303 CmdArgs.push_back("-lbundle1.o");
4304 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004305 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004306 CmdArgs.push_back("-lbundle1.o");
4307 }
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004308 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004309 } else {
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004310 if (Args.hasArg(options::OPT_pg) &&
4311 getToolChain().SupportsProfiling()) {
Daniel Dunbarc1964212009-03-26 16:23:12 +00004312 if (Args.hasArg(options::OPT_static) ||
4313 Args.hasArg(options::OPT_object) ||
4314 Args.hasArg(options::OPT_preload)) {
4315 CmdArgs.push_back("-lgcrt0.o");
4316 } else {
4317 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004318
Daniel Dunbarc1964212009-03-26 16:23:12 +00004319 // darwin_crt2 spec is empty.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004320 }
Bob Wilsonef285b42012-07-04 00:18:41 +00004321 // By default on OS X 10.8 and later, we don't link with a crt1.o
4322 // file and the linker knows to use _main as the entry point. But,
4323 // when compiling with -pg, we need to link with the gcrt1.o file,
4324 // so pass the -no_new_main option to tell the linker to use the
4325 // "start" symbol as the entry point.
Bob Wilson1e148fe2012-07-03 20:42:10 +00004326 if (getDarwinToolChain().isTargetMacOS() &&
4327 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4328 CmdArgs.push_back("-no_new_main");
Daniel Dunbarc1964212009-03-26 16:23:12 +00004329 } else {
4330 if (Args.hasArg(options::OPT_static) ||
4331 Args.hasArg(options::OPT_object) ||
4332 Args.hasArg(options::OPT_preload)) {
4333 CmdArgs.push_back("-lcrt0.o");
4334 } else {
4335 // Derived from darwin_crt1 spec.
Daniel Dunbarebc34df2011-03-31 17:12:33 +00004336 if (getDarwinToolChain().isTargetIOSSimulator()) {
4337 // The simulator doesn't have a versioned crt1 file.
4338 CmdArgs.push_back("-lcrt1.o");
4339 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004340 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4341 CmdArgs.push_back("-lcrt1.o");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004342 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
Daniel Dunbar83608032010-01-27 00:56:56 +00004343 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004344 } else {
4345 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4346 CmdArgs.push_back("-lcrt1.o");
4347 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4348 CmdArgs.push_back("-lcrt1.10.5.o");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004349 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004350 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004351
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004352 // darwin_crt2 spec is empty.
4353 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004354 }
4355 }
4356 }
4357 }
4358
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004359 if (!getDarwinToolChain().isTargetIPhoneOS() &&
4360 Args.hasArg(options::OPT_shared_libgcc) &&
4361 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004362 const char *Str =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004363 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004364 CmdArgs.push_back(Str);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004365 }
4366 }
4367
4368 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004369
Alexey Samsonov627b10f2012-11-06 15:09:03 +00004370 SanitizerArgs Sanitize(getToolChain().getDriver(), Args);
Alexey Samsonov969be242013-01-21 08:45:02 +00004371 // If we're building a dynamic lib with -fsanitize=address,
4372 // unresolved symbols may appear. Mark all
Alexey Samsonovcc429802012-11-16 12:53:14 +00004373 // of them as dynamic_lookup. Linking executables is handled in
4374 // lib/Driver/ToolChains.cpp.
Alexey Samsonov969be242013-01-21 08:45:02 +00004375 if (Sanitize.needsAsanRt()) {
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00004376 if (Args.hasArg(options::OPT_dynamiclib) ||
4377 Args.hasArg(options::OPT_bundle)) {
4378 CmdArgs.push_back("-undefined");
4379 CmdArgs.push_back("dynamic_lookup");
4380 }
4381 }
4382
Daniel Dunbarc1964212009-03-26 16:23:12 +00004383 if (Args.hasArg(options::OPT_fopenmp))
4384 // This is more complicated in gcc...
4385 CmdArgs.push_back("-lgomp");
4386
Douglas Gregor9295df02012-05-15 21:00:27 +00004387 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4388
Bob Wilson16d93952012-05-15 18:57:39 +00004389 if (isObjCRuntimeLinked(Args) &&
4390 !Args.hasArg(options::OPT_nostdlib) &&
4391 !Args.hasArg(options::OPT_nodefaultlibs)) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004392 // Avoid linking compatibility stubs on i386 mac.
4393 if (!getDarwinToolChain().isTargetMacOS() ||
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004394 getDarwinToolChain().getArch() != llvm::Triple::x86) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004395 // If we don't have ARC or subscripting runtime support, link in the
4396 // runtime stubs. We have to do this *before* adding any of the normal
4397 // linker inputs so that its initializer gets run first.
John McCall5fb5df92012-06-20 06:18:46 +00004398 ObjCRuntime runtime =
4399 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004400 // We use arclite library for both ARC and subscripting support.
John McCall3deb1ad2012-08-21 02:47:43 +00004401 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
John McCall5fb5df92012-06-20 06:18:46 +00004402 !runtime.hasSubscripting())
Ted Kremeneke65b0862012-03-06 20:05:56 +00004403 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004404 }
Bob Wilson7dda0cd2012-04-21 00:21:42 +00004405 CmdArgs.push_back("-framework");
4406 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004407 // Link libobj.
4408 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00004409 }
John McCall31168b02011-06-15 23:02:42 +00004410
Daniel Dunbarc1964212009-03-26 16:23:12 +00004411 if (LinkingOutput) {
4412 CmdArgs.push_back("-arch_multiple");
4413 CmdArgs.push_back("-final_output");
4414 CmdArgs.push_back(LinkingOutput);
4415 }
4416
Daniel Dunbarc1964212009-03-26 16:23:12 +00004417 if (Args.hasArg(options::OPT_fnested_functions))
4418 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004419
Daniel Dunbarc1964212009-03-26 16:23:12 +00004420 if (!Args.hasArg(options::OPT_nostdlib) &&
4421 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004422 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004423 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00004424
Daniel Dunbarc1964212009-03-26 16:23:12 +00004425 // link_ssp spec is empty.
4426
Daniel Dunbar26d482a2009-09-18 08:15:03 +00004427 // Let the tool chain choose which runtime library to link.
4428 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004429 }
4430
Chad Rosier06fd3c62012-05-16 23:45:12 +00004431 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004432 !Args.hasArg(options::OPT_nostartfiles)) {
4433 // endfile_spec is empty.
4434 }
4435
4436 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4437 Args.AddAllArgs(CmdArgs, options::OPT_F);
4438
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004439 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004440 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004441 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00004442}
4443
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004444void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004445 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004446 const InputInfoList &Inputs,
4447 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004448 const char *LinkingOutput) const {
4449 ArgStringList CmdArgs;
4450
4451 CmdArgs.push_back("-create");
4452 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004453
4454 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004455 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004456
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004457 for (InputInfoList::const_iterator
4458 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4459 const InputInfo &II = *it;
4460 assert(II.isFilename() && "Unexpected lipo input.");
4461 CmdArgs.push_back(II.getFilename());
4462 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004463 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004464 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004465 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004466}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004467
Daniel Dunbar88299622010-06-04 18:28:36 +00004468void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004469 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00004470 const InputInfoList &Inputs,
4471 const ArgList &Args,
4472 const char *LinkingOutput) const {
4473 ArgStringList CmdArgs;
4474
Daniel Dunbareb86b042011-05-09 17:23:16 +00004475 CmdArgs.push_back("-o");
4476 CmdArgs.push_back(Output.getFilename());
4477
Daniel Dunbar88299622010-06-04 18:28:36 +00004478 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4479 const InputInfo &Input = Inputs[0];
4480 assert(Input.isFilename() && "Unexpected dsymutil input.");
4481 CmdArgs.push_back(Input.getFilename());
4482
Daniel Dunbar88299622010-06-04 18:28:36 +00004483 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004484 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004485 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00004486}
4487
Eric Christopher551ef452011-08-23 17:56:55 +00004488void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00004489 const InputInfo &Output,
4490 const InputInfoList &Inputs,
4491 const ArgList &Args,
4492 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00004493 ArgStringList CmdArgs;
4494 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00004495 CmdArgs.push_back("--debug-info");
4496 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00004497 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00004498
4499 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4500 const InputInfo &Input = Inputs[0];
4501 assert(Input.isFilename() && "Unexpected verify input");
4502
4503 // Grabbing the output of the earlier dsymutil run.
4504 CmdArgs.push_back(Input.getFilename());
4505
4506 const char *Exec =
4507 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4508 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4509}
4510
David Chisnallf571cde2012-02-15 13:39:01 +00004511void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4512 const InputInfo &Output,
4513 const InputInfoList &Inputs,
4514 const ArgList &Args,
4515 const char *LinkingOutput) const {
4516 ArgStringList CmdArgs;
4517
4518 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4519 options::OPT_Xassembler);
4520
4521 CmdArgs.push_back("-o");
4522 CmdArgs.push_back(Output.getFilename());
4523
4524 for (InputInfoList::const_iterator
4525 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4526 const InputInfo &II = *it;
4527 CmdArgs.push_back(II.getFilename());
4528 }
4529
4530 const char *Exec =
4531 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4532 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4533}
4534
4535
4536void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4537 const InputInfo &Output,
4538 const InputInfoList &Inputs,
4539 const ArgList &Args,
4540 const char *LinkingOutput) const {
4541 // FIXME: Find a real GCC, don't hard-code versions here
4542 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4543 const llvm::Triple &T = getToolChain().getTriple();
4544 std::string LibPath = "/usr/lib/";
4545 llvm::Triple::ArchType Arch = T.getArch();
4546 switch (Arch) {
4547 case llvm::Triple::x86:
4548 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4549 T.getOSName()).str() + "/4.5.2/";
4550 break;
4551 case llvm::Triple::x86_64:
4552 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4553 T.getOSName()).str();
4554 GCCLibPath += "/4.5.2/amd64/";
4555 LibPath += "amd64/";
4556 break;
4557 default:
4558 assert(0 && "Unsupported architecture");
4559 }
4560
4561 ArgStringList CmdArgs;
4562
David Chisnall272a0712012-02-29 15:06:12 +00004563 // Demangle C++ names in errors
4564 CmdArgs.push_back("-C");
4565
David Chisnallf571cde2012-02-15 13:39:01 +00004566 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4567 (!Args.hasArg(options::OPT_shared))) {
4568 CmdArgs.push_back("-e");
4569 CmdArgs.push_back("_start");
4570 }
4571
4572 if (Args.hasArg(options::OPT_static)) {
4573 CmdArgs.push_back("-Bstatic");
4574 CmdArgs.push_back("-dn");
4575 } else {
4576 CmdArgs.push_back("-Bdynamic");
4577 if (Args.hasArg(options::OPT_shared)) {
4578 CmdArgs.push_back("-shared");
4579 } else {
4580 CmdArgs.push_back("--dynamic-linker");
4581 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
4582 }
4583 }
4584
4585 if (Output.isFilename()) {
4586 CmdArgs.push_back("-o");
4587 CmdArgs.push_back(Output.getFilename());
4588 } else {
4589 assert(Output.isNothing() && "Invalid output.");
4590 }
4591
4592 if (!Args.hasArg(options::OPT_nostdlib) &&
4593 !Args.hasArg(options::OPT_nostartfiles)) {
4594 if (!Args.hasArg(options::OPT_shared)) {
4595 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
4596 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004597 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004598 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4599 } else {
4600 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004601 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4602 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004603 }
David Chisnallddc4c9d2012-03-13 14:14:54 +00004604 if (getToolChain().getDriver().CCCIsCXX)
4605 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004606 }
4607
4608 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
4609
4610 Args.AddAllArgs(CmdArgs, options::OPT_L);
4611 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4612 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00004613 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00004614
4615 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4616
4617 if (!Args.hasArg(options::OPT_nostdlib) &&
4618 !Args.hasArg(options::OPT_nodefaultlibs)) {
David Chisnall3d127c72012-04-10 11:49:50 +00004619 if (getToolChain().getDriver().CCCIsCXX)
4620 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00004621 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004622 if (!Args.hasArg(options::OPT_shared)) {
4623 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00004624 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00004625 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004626 }
David Chisnallf571cde2012-02-15 13:39:01 +00004627 }
4628
4629 if (!Args.hasArg(options::OPT_nostdlib) &&
4630 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00004631 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004632 }
David Chisnall96de9932012-02-16 16:00:47 +00004633 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004634
4635 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4636
4637 const char *Exec =
4638 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4639 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4640}
4641
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004642void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004643 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004644 const InputInfoList &Inputs,
4645 const ArgList &Args,
4646 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004647 ArgStringList CmdArgs;
4648
4649 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4650 options::OPT_Xassembler);
4651
4652 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004653 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004654
4655 for (InputInfoList::const_iterator
4656 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4657 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004658 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004659 }
4660
4661 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004662 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004663 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004664}
4665
4666void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004667 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004668 const InputInfoList &Inputs,
4669 const ArgList &Args,
4670 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004671 ArgStringList CmdArgs;
4672
4673 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004674 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004675 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004676 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004677 }
4678
4679 if (Args.hasArg(options::OPT_static)) {
4680 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004681 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004682 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00004683// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004684 CmdArgs.push_back("-Bdynamic");
4685 if (Args.hasArg(options::OPT_shared)) {
4686 CmdArgs.push_back("-shared");
4687 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00004688 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004689 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
4690 }
4691 }
4692
Daniel Dunbarb440f562010-08-02 02:38:21 +00004693 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004694 CmdArgs.push_back("-o");
4695 CmdArgs.push_back(Output.getFilename());
4696 } else {
4697 assert(Output.isNothing() && "Invalid output.");
4698 }
4699
4700 if (!Args.hasArg(options::OPT_nostdlib) &&
4701 !Args.hasArg(options::OPT_nostartfiles)) {
4702 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004703 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004704 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004705 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004706 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004707 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004708 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004709 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004710 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004711 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004712 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00004713 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004714 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004715 }
4716
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004717 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
4718 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00004719 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004720
4721 Args.AddAllArgs(CmdArgs, options::OPT_L);
4722 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4723 Args.AddAllArgs(CmdArgs, options::OPT_e);
4724
Daniel Dunbar54423b22010-09-17 00:24:54 +00004725 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004726
4727 if (!Args.hasArg(options::OPT_nostdlib) &&
4728 !Args.hasArg(options::OPT_nodefaultlibs)) {
4729 // FIXME: For some reason GCC passes -lgcc before adding
4730 // the default system libraries. Just mimic this for now.
4731 CmdArgs.push_back("-lgcc");
4732
4733 if (Args.hasArg(options::OPT_pthread))
4734 CmdArgs.push_back("-pthread");
4735 if (!Args.hasArg(options::OPT_shared))
4736 CmdArgs.push_back("-lc");
4737 CmdArgs.push_back("-lgcc");
4738 }
4739
4740 if (!Args.hasArg(options::OPT_nostdlib) &&
4741 !Args.hasArg(options::OPT_nostartfiles)) {
4742 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00004743 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004744 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004745 }
4746
Bill Wendling08760582011-06-27 19:15:03 +00004747 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00004748
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004749 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004750 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004751 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004752}
4753
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004754void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004755 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004756 const InputInfoList &Inputs,
4757 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00004758 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004759 ArgStringList CmdArgs;
4760
4761 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4762 options::OPT_Xassembler);
4763
4764 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004765 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004766
4767 for (InputInfoList::const_iterator
4768 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4769 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00004770 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004771 }
4772
4773 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004774 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004775 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004776}
4777
4778void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004779 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004780 const InputInfoList &Inputs,
4781 const ArgList &Args,
4782 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004783 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004784 ArgStringList CmdArgs;
4785
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00004786 // Silence warning for "clang -g foo.o -o foo"
4787 Args.ClaimAllArgs(options::OPT_g_Group);
4788 // and "clang -emit-llvm foo.o -o foo"
4789 Args.ClaimAllArgs(options::OPT_emit_llvm);
4790 // and for "clang -w foo.o -o foo". Other warning options are already
4791 // handled somewhere else.
4792 Args.ClaimAllArgs(options::OPT_w);
4793
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004794 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004795 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004796 CmdArgs.push_back("-e");
4797 CmdArgs.push_back("__start");
4798 }
4799
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004800 if (Args.hasArg(options::OPT_static)) {
4801 CmdArgs.push_back("-Bstatic");
4802 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00004803 if (Args.hasArg(options::OPT_rdynamic))
4804 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004805 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004806 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004807 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004808 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004809 } else {
4810 CmdArgs.push_back("-dynamic-linker");
4811 CmdArgs.push_back("/usr/libexec/ld.so");
4812 }
4813 }
4814
Daniel Dunbarb440f562010-08-02 02:38:21 +00004815 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004816 CmdArgs.push_back("-o");
4817 CmdArgs.push_back(Output.getFilename());
4818 } else {
4819 assert(Output.isNothing() && "Invalid output.");
4820 }
4821
4822 if (!Args.hasArg(options::OPT_nostdlib) &&
4823 !Args.hasArg(options::OPT_nostartfiles)) {
4824 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00004825 if (Args.hasArg(options::OPT_pg))
4826 CmdArgs.push_back(Args.MakeArgString(
4827 getToolChain().GetFilePath("gcrt0.o")));
4828 else
4829 CmdArgs.push_back(Args.MakeArgString(
4830 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00004831 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004832 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004833 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00004834 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004835 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004836 }
4837 }
4838
Edward O'Callaghan5c521462009-10-28 15:13:08 +00004839 std::string Triple = getToolChain().getTripleString();
4840 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004841 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00004842 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004843 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004844
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004845 Args.AddAllArgs(CmdArgs, options::OPT_L);
4846 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4847 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00004848 Args.AddAllArgs(CmdArgs, options::OPT_s);
4849 Args.AddAllArgs(CmdArgs, options::OPT_t);
4850 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4851 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004852
Daniel Dunbar54423b22010-09-17 00:24:54 +00004853 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004854
4855 if (!Args.hasArg(options::OPT_nostdlib) &&
4856 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004857 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004858 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00004859 if (Args.hasArg(options::OPT_pg))
4860 CmdArgs.push_back("-lm_p");
4861 else
4862 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00004863 }
4864
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004865 // FIXME: For some reason GCC passes -lgcc before adding
4866 // the default system libraries. Just mimic this for now.
4867 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004868
Eric Christopher17674ec2012-09-13 06:32:34 +00004869 if (Args.hasArg(options::OPT_pthread)) {
4870 if (!Args.hasArg(options::OPT_shared) &&
4871 Args.hasArg(options::OPT_pg))
4872 CmdArgs.push_back("-lpthread_p");
4873 else
4874 CmdArgs.push_back("-lpthread");
4875 }
4876
Chandler Carruth45661652011-12-17 22:32:42 +00004877 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00004878 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00004879 CmdArgs.push_back("-lc_p");
4880 else
4881 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00004882 }
Eric Christopher17674ec2012-09-13 06:32:34 +00004883
Daniel Dunbara8888ac2009-08-03 01:28:59 +00004884 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004885 }
4886
4887 if (!Args.hasArg(options::OPT_nostdlib) &&
4888 !Args.hasArg(options::OPT_nostartfiles)) {
4889 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00004890 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004891 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004892 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00004893 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004894 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004895 }
4896
4897 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004898 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004899 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004900}
Ed Schoutene33194b2009-04-02 19:13:12 +00004901
Eli Friedman9fa28852012-08-08 23:57:20 +00004902void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4903 const InputInfo &Output,
4904 const InputInfoList &Inputs,
4905 const ArgList &Args,
4906 const char *LinkingOutput) const {
4907 ArgStringList CmdArgs;
4908
4909 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4910 options::OPT_Xassembler);
4911
4912 CmdArgs.push_back("-o");
4913 CmdArgs.push_back(Output.getFilename());
4914
4915 for (InputInfoList::const_iterator
4916 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4917 const InputInfo &II = *it;
4918 CmdArgs.push_back(II.getFilename());
4919 }
4920
4921 const char *Exec =
4922 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4923 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4924}
4925
4926void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
4927 const InputInfo &Output,
4928 const InputInfoList &Inputs,
4929 const ArgList &Args,
4930 const char *LinkingOutput) const {
4931 const Driver &D = getToolChain().getDriver();
4932 ArgStringList CmdArgs;
4933
4934 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4935 (!Args.hasArg(options::OPT_shared))) {
4936 CmdArgs.push_back("-e");
4937 CmdArgs.push_back("__start");
4938 }
4939
4940 if (Args.hasArg(options::OPT_static)) {
4941 CmdArgs.push_back("-Bstatic");
4942 } else {
4943 if (Args.hasArg(options::OPT_rdynamic))
4944 CmdArgs.push_back("-export-dynamic");
4945 CmdArgs.push_back("--eh-frame-hdr");
4946 CmdArgs.push_back("-Bdynamic");
4947 if (Args.hasArg(options::OPT_shared)) {
4948 CmdArgs.push_back("-shared");
4949 } else {
4950 CmdArgs.push_back("-dynamic-linker");
4951 CmdArgs.push_back("/usr/libexec/ld.so");
4952 }
4953 }
4954
4955 if (Output.isFilename()) {
4956 CmdArgs.push_back("-o");
4957 CmdArgs.push_back(Output.getFilename());
4958 } else {
4959 assert(Output.isNothing() && "Invalid output.");
4960 }
4961
4962 if (!Args.hasArg(options::OPT_nostdlib) &&
4963 !Args.hasArg(options::OPT_nostartfiles)) {
4964 if (!Args.hasArg(options::OPT_shared)) {
4965 if (Args.hasArg(options::OPT_pg))
4966 CmdArgs.push_back(Args.MakeArgString(
4967 getToolChain().GetFilePath("gcrt0.o")));
4968 else
4969 CmdArgs.push_back(Args.MakeArgString(
4970 getToolChain().GetFilePath("crt0.o")));
4971 CmdArgs.push_back(Args.MakeArgString(
4972 getToolChain().GetFilePath("crtbegin.o")));
4973 } else {
4974 CmdArgs.push_back(Args.MakeArgString(
4975 getToolChain().GetFilePath("crtbeginS.o")));
4976 }
4977 }
4978
4979 Args.AddAllArgs(CmdArgs, options::OPT_L);
4980 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4981 Args.AddAllArgs(CmdArgs, options::OPT_e);
4982
4983 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4984
4985 if (!Args.hasArg(options::OPT_nostdlib) &&
4986 !Args.hasArg(options::OPT_nodefaultlibs)) {
4987 if (D.CCCIsCXX) {
4988 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4989 if (Args.hasArg(options::OPT_pg))
4990 CmdArgs.push_back("-lm_p");
4991 else
4992 CmdArgs.push_back("-lm");
4993 }
4994
Rafael Espindola1ad26f02012-10-23 17:07:31 +00004995 if (Args.hasArg(options::OPT_pthread)) {
4996 if (!Args.hasArg(options::OPT_shared) &&
4997 Args.hasArg(options::OPT_pg))
4998 CmdArgs.push_back("-lpthread_p");
4999 else
5000 CmdArgs.push_back("-lpthread");
5001 }
5002
Eli Friedman9fa28852012-08-08 23:57:20 +00005003 if (!Args.hasArg(options::OPT_shared)) {
5004 if (Args.hasArg(options::OPT_pg))
5005 CmdArgs.push_back("-lc_p");
5006 else
5007 CmdArgs.push_back("-lc");
5008 }
5009
5010 std::string myarch = "-lclang_rt.";
5011 const llvm::Triple &T = getToolChain().getTriple();
5012 llvm::Triple::ArchType Arch = T.getArch();
5013 switch (Arch) {
5014 case llvm::Triple::arm:
5015 myarch += ("arm");
5016 break;
5017 case llvm::Triple::x86:
5018 myarch += ("i386");
5019 break;
5020 case llvm::Triple::x86_64:
5021 myarch += ("amd64");
5022 break;
5023 default:
5024 assert(0 && "Unsupported architecture");
5025 }
5026 CmdArgs.push_back(Args.MakeArgString(myarch));
5027 }
5028
5029 if (!Args.hasArg(options::OPT_nostdlib) &&
5030 !Args.hasArg(options::OPT_nostartfiles)) {
5031 if (!Args.hasArg(options::OPT_shared))
5032 CmdArgs.push_back(Args.MakeArgString(
5033 getToolChain().GetFilePath("crtend.o")));
5034 else
5035 CmdArgs.push_back(Args.MakeArgString(
5036 getToolChain().GetFilePath("crtendS.o")));
5037 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005038
5039 const char *Exec =
5040 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5041 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00005042}
5043
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005044void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005045 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005046 const InputInfoList &Inputs,
5047 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005048 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005049 ArgStringList CmdArgs;
5050
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005051 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5052 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005053 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005054 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005055 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00005056 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005057 else if (getToolChain().getArch() == llvm::Triple::mips ||
5058 getToolChain().getArch() == llvm::Triple::mipsel ||
5059 getToolChain().getArch() == llvm::Triple::mips64 ||
5060 getToolChain().getArch() == llvm::Triple::mips64el) {
5061 StringRef CPUName;
5062 StringRef ABIName;
5063 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005064
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005065 CmdArgs.push_back("-march");
5066 CmdArgs.push_back(CPUName.data());
5067
5068 // Convert ABI name to the GNU tools acceptable variant.
5069 if (ABIName == "o32")
5070 ABIName = "32";
5071 else if (ABIName == "n64")
5072 ABIName = "64";
5073
5074 CmdArgs.push_back("-mabi");
5075 CmdArgs.push_back(ABIName.data());
5076
5077 if (getToolChain().getArch() == llvm::Triple::mips ||
5078 getToolChain().getArch() == llvm::Triple::mips64)
5079 CmdArgs.push_back("-EB");
5080 else
5081 CmdArgs.push_back("-EL");
5082
5083 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5084 options::OPT_fpic, options::OPT_fno_pic,
5085 options::OPT_fPIE, options::OPT_fno_PIE,
5086 options::OPT_fpie, options::OPT_fno_pie);
5087 if (LastPICArg &&
5088 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5089 LastPICArg->getOption().matches(options::OPT_fpic) ||
5090 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5091 LastPICArg->getOption().matches(options::OPT_fpie))) {
5092 CmdArgs.push_back("-KPIC");
5093 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +00005094 } else if (getToolChain().getArch() == llvm::Triple::arm ||
5095 getToolChain().getArch() == llvm::Triple::thumb) {
5096 CmdArgs.push_back("-mfpu=softvfp");
5097 switch(getToolChain().getTriple().getEnvironment()) {
5098 case llvm::Triple::GNUEABI:
5099 case llvm::Triple::EABI:
5100 break;
5101
5102 default:
5103 CmdArgs.push_back("-matpcs");
5104 }
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005105 }
Eric Christopher0b26a612010-03-02 02:41:08 +00005106
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005107 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5108 options::OPT_Xassembler);
5109
5110 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005111 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005112
5113 for (InputInfoList::const_iterator
5114 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5115 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005116 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005117 }
5118
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005119 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005120 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005121 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005122}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005123
5124void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005125 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005126 const InputInfoList &Inputs,
5127 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005128 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00005129 const toolchains::FreeBSD& ToolChain =
5130 static_cast<const toolchains::FreeBSD&>(getToolChain());
5131 const Driver &D = ToolChain.getDriver();
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005132 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00005133
5134 // Silence warning for "clang -g foo.o -o foo"
5135 Args.ClaimAllArgs(options::OPT_g_Group);
5136 // and "clang -emit-llvm foo.o -o foo"
5137 Args.ClaimAllArgs(options::OPT_emit_llvm);
5138 // and for "clang -w foo.o -o foo". Other warning options are already
5139 // handled somewhere else.
5140 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005141
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005142 if (!D.SysRoot.empty())
5143 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5144
Roman Divackyafe2f232012-08-28 15:09:03 +00005145 if (Args.hasArg(options::OPT_pie))
5146 CmdArgs.push_back("-pie");
5147
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005148 if (Args.hasArg(options::OPT_static)) {
5149 CmdArgs.push_back("-Bstatic");
5150 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005151 if (Args.hasArg(options::OPT_rdynamic))
5152 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005153 CmdArgs.push_back("--eh-frame-hdr");
5154 if (Args.hasArg(options::OPT_shared)) {
5155 CmdArgs.push_back("-Bshareable");
5156 } else {
5157 CmdArgs.push_back("-dynamic-linker");
5158 CmdArgs.push_back("/libexec/ld-elf.so.1");
5159 }
Roman Divackyafe2f232012-08-28 15:09:03 +00005160 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5161 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00005162 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5163 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5164 CmdArgs.push_back("--hash-style=both");
5165 }
5166 }
5167 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005168 }
5169
5170 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5171 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005172 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005173 CmdArgs.push_back("-m");
5174 CmdArgs.push_back("elf_i386_fbsd");
5175 }
5176
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005177 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00005178 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00005179 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00005180 }
5181
Daniel Dunbarb440f562010-08-02 02:38:21 +00005182 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005183 CmdArgs.push_back("-o");
5184 CmdArgs.push_back(Output.getFilename());
5185 } else {
5186 assert(Output.isNothing() && "Invalid output.");
5187 }
5188
5189 if (!Args.hasArg(options::OPT_nostdlib) &&
5190 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00005191 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005192 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00005193 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00005194 crt1 = "gcrt1.o";
5195 else if (Args.hasArg(options::OPT_pie))
5196 crt1 = "Scrt1.o";
5197 else
5198 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005199 }
Roman Divackyafe2f232012-08-28 15:09:03 +00005200 if (crt1)
5201 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5202
5203 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5204
5205 const char *crtbegin = NULL;
5206 if (Args.hasArg(options::OPT_static))
5207 crtbegin = "crtbeginT.o";
5208 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5209 crtbegin = "crtbeginS.o";
5210 else
5211 crtbegin = "crtbegin.o";
5212
5213 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005214 }
5215
5216 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00005217 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00005218 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5219 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005220 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005221 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5222 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00005223 Args.AddAllArgs(CmdArgs, options::OPT_s);
5224 Args.AddAllArgs(CmdArgs, options::OPT_t);
5225 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5226 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005227
Roman Divackyafe2f232012-08-28 15:09:03 +00005228 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005229
5230 if (!Args.hasArg(options::OPT_nostdlib) &&
5231 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00005232 if (D.CCCIsCXX) {
Roman Divackyafe2f232012-08-28 15:09:03 +00005233 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00005234 if (Args.hasArg(options::OPT_pg))
5235 CmdArgs.push_back("-lm_p");
5236 else
5237 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00005238 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005239 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5240 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00005241 if (Args.hasArg(options::OPT_pg))
5242 CmdArgs.push_back("-lgcc_p");
5243 else
5244 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005245 if (Args.hasArg(options::OPT_static)) {
5246 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005247 } else if (Args.hasArg(options::OPT_pg)) {
5248 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005249 } else {
5250 CmdArgs.push_back("--as-needed");
5251 CmdArgs.push_back("-lgcc_s");
5252 CmdArgs.push_back("--no-as-needed");
5253 }
5254
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005255 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00005256 if (Args.hasArg(options::OPT_pg))
5257 CmdArgs.push_back("-lpthread_p");
5258 else
5259 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005260 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005261
Roman Divacky66f22762011-02-10 16:59:40 +00005262 if (Args.hasArg(options::OPT_pg)) {
5263 if (Args.hasArg(options::OPT_shared))
5264 CmdArgs.push_back("-lc");
5265 else
5266 CmdArgs.push_back("-lc_p");
5267 CmdArgs.push_back("-lgcc_p");
5268 } else {
5269 CmdArgs.push_back("-lc");
5270 CmdArgs.push_back("-lgcc");
5271 }
5272
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005273 if (Args.hasArg(options::OPT_static)) {
5274 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005275 } else if (Args.hasArg(options::OPT_pg)) {
5276 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005277 } else {
5278 CmdArgs.push_back("--as-needed");
5279 CmdArgs.push_back("-lgcc_s");
5280 CmdArgs.push_back("--no-as-needed");
5281 }
5282 }
5283
5284 if (!Args.hasArg(options::OPT_nostdlib) &&
5285 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackya3c50242012-09-07 13:36:21 +00005286 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Roman Divackyafe2f232012-08-28 15:09:03 +00005287 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00005288 else
5289 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00005290 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005291 }
5292
Roman Divackyafe2f232012-08-28 15:09:03 +00005293 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005294
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005295 const char *Exec =
Roman Divackyafe2f232012-08-28 15:09:03 +00005296 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005297 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005298}
Daniel Dunbarcc912342009-05-02 18:28:39 +00005299
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005300void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5301 const InputInfo &Output,
5302 const InputInfoList &Inputs,
5303 const ArgList &Args,
5304 const char *LinkingOutput) const {
5305 ArgStringList CmdArgs;
5306
5307 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5308 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005309 if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005310 CmdArgs.push_back("--32");
5311
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005312 // Set byte order explicitly
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005313 if (getToolChain().getArch() == llvm::Triple::mips)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005314 CmdArgs.push_back("-EB");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005315 else if (getToolChain().getArch() == llvm::Triple::mipsel)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005316 CmdArgs.push_back("-EL");
5317
5318 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5319 options::OPT_Xassembler);
5320
5321 CmdArgs.push_back("-o");
5322 CmdArgs.push_back(Output.getFilename());
5323
5324 for (InputInfoList::const_iterator
5325 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5326 const InputInfo &II = *it;
5327 CmdArgs.push_back(II.getFilename());
5328 }
5329
David Chisnallddbd68f2011-09-27 22:03:18 +00005330 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005331 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5332}
5333
5334void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5335 const InputInfo &Output,
5336 const InputInfoList &Inputs,
5337 const ArgList &Args,
5338 const char *LinkingOutput) const {
5339 const Driver &D = getToolChain().getDriver();
5340 ArgStringList CmdArgs;
5341
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005342 if (!D.SysRoot.empty())
5343 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5344
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005345 if (Args.hasArg(options::OPT_static)) {
5346 CmdArgs.push_back("-Bstatic");
5347 } else {
5348 if (Args.hasArg(options::OPT_rdynamic))
5349 CmdArgs.push_back("-export-dynamic");
5350 CmdArgs.push_back("--eh-frame-hdr");
5351 if (Args.hasArg(options::OPT_shared)) {
5352 CmdArgs.push_back("-Bshareable");
5353 } else {
5354 CmdArgs.push_back("-dynamic-linker");
5355 CmdArgs.push_back("/libexec/ld.elf_so");
5356 }
5357 }
5358
5359 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5360 // instruct ld in the base system to link 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005361 if (getToolChain().getArch() == llvm::Triple::x86) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005362 CmdArgs.push_back("-m");
5363 CmdArgs.push_back("elf_i386");
5364 }
5365
5366 if (Output.isFilename()) {
5367 CmdArgs.push_back("-o");
5368 CmdArgs.push_back(Output.getFilename());
5369 } else {
5370 assert(Output.isNothing() && "Invalid output.");
5371 }
5372
5373 if (!Args.hasArg(options::OPT_nostdlib) &&
5374 !Args.hasArg(options::OPT_nostartfiles)) {
5375 if (!Args.hasArg(options::OPT_shared)) {
5376 CmdArgs.push_back(Args.MakeArgString(
5377 getToolChain().GetFilePath("crt0.o")));
5378 CmdArgs.push_back(Args.MakeArgString(
5379 getToolChain().GetFilePath("crti.o")));
5380 CmdArgs.push_back(Args.MakeArgString(
5381 getToolChain().GetFilePath("crtbegin.o")));
5382 } else {
5383 CmdArgs.push_back(Args.MakeArgString(
5384 getToolChain().GetFilePath("crti.o")));
5385 CmdArgs.push_back(Args.MakeArgString(
5386 getToolChain().GetFilePath("crtbeginS.o")));
5387 }
5388 }
5389
5390 Args.AddAllArgs(CmdArgs, options::OPT_L);
5391 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5392 Args.AddAllArgs(CmdArgs, options::OPT_e);
5393 Args.AddAllArgs(CmdArgs, options::OPT_s);
5394 Args.AddAllArgs(CmdArgs, options::OPT_t);
5395 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5396 Args.AddAllArgs(CmdArgs, options::OPT_r);
5397
5398 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5399
5400 if (!Args.hasArg(options::OPT_nostdlib) &&
5401 !Args.hasArg(options::OPT_nodefaultlibs)) {
5402 if (D.CCCIsCXX) {
5403 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5404 CmdArgs.push_back("-lm");
5405 }
5406 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5407 // the default system libraries. Just mimic this for now.
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005408 if (Args.hasArg(options::OPT_static)) {
5409 CmdArgs.push_back("-lgcc_eh");
5410 } else {
5411 CmdArgs.push_back("--as-needed");
5412 CmdArgs.push_back("-lgcc_s");
5413 CmdArgs.push_back("--no-as-needed");
5414 }
Joerg Sonnenberger87717772011-06-07 23:39:17 +00005415 CmdArgs.push_back("-lgcc");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005416
5417 if (Args.hasArg(options::OPT_pthread))
5418 CmdArgs.push_back("-lpthread");
5419 CmdArgs.push_back("-lc");
5420
5421 CmdArgs.push_back("-lgcc");
5422 if (Args.hasArg(options::OPT_static)) {
5423 CmdArgs.push_back("-lgcc_eh");
5424 } else {
5425 CmdArgs.push_back("--as-needed");
5426 CmdArgs.push_back("-lgcc_s");
5427 CmdArgs.push_back("--no-as-needed");
5428 }
5429 }
5430
5431 if (!Args.hasArg(options::OPT_nostdlib) &&
5432 !Args.hasArg(options::OPT_nostartfiles)) {
5433 if (!Args.hasArg(options::OPT_shared))
5434 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5435 "crtend.o")));
5436 else
5437 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5438 "crtendS.o")));
5439 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5440 "crtn.o")));
5441 }
5442
Bill Wendling08760582011-06-27 19:15:03 +00005443 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005444
David Chisnallddbd68f2011-09-27 22:03:18 +00005445 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005446 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5447}
5448
Rafael Espindola92b00932010-08-10 00:25:48 +00005449void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5450 const InputInfo &Output,
5451 const InputInfoList &Inputs,
5452 const ArgList &Args,
5453 const char *LinkingOutput) const {
5454 ArgStringList CmdArgs;
5455
5456 // Add --32/--64 to make sure we get the format we want.
5457 // This is incomplete
5458 if (getToolChain().getArch() == llvm::Triple::x86) {
5459 CmdArgs.push_back("--32");
5460 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5461 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00005462 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5463 CmdArgs.push_back("-a32");
5464 CmdArgs.push_back("-mppc");
5465 CmdArgs.push_back("-many");
5466 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5467 CmdArgs.push_back("-a64");
5468 CmdArgs.push_back("-mppc64");
5469 CmdArgs.push_back("-many");
Rafael Espindola92b00932010-08-10 00:25:48 +00005470 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005471 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00005472 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5473 CmdArgs.push_back("-mfpu=neon");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00005474
5475 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5476 getToolChain().getTriple());
5477 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00005478
5479 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5480 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5481 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005482 } else if (getToolChain().getArch() == llvm::Triple::mips ||
5483 getToolChain().getArch() == llvm::Triple::mipsel ||
5484 getToolChain().getArch() == llvm::Triple::mips64 ||
5485 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005486 StringRef CPUName;
5487 StringRef ABIName;
5488 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005489
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005490 CmdArgs.push_back("-march");
5491 CmdArgs.push_back(CPUName.data());
5492
5493 // Convert ABI name to the GNU tools acceptable variant.
5494 if (ABIName == "o32")
5495 ABIName = "32";
5496 else if (ABIName == "n64")
5497 ABIName = "64";
5498
5499 CmdArgs.push_back("-mabi");
5500 CmdArgs.push_back(ABIName.data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00005501
5502 if (getToolChain().getArch() == llvm::Triple::mips ||
5503 getToolChain().getArch() == llvm::Triple::mips64)
5504 CmdArgs.push_back("-EB");
5505 else
5506 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00005507
5508 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5509 options::OPT_fpic, options::OPT_fno_pic,
5510 options::OPT_fPIE, options::OPT_fno_PIE,
5511 options::OPT_fpie, options::OPT_fno_pie);
5512 if (LastPICArg &&
5513 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5514 LastPICArg->getOption().matches(options::OPT_fpic) ||
5515 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5516 LastPICArg->getOption().matches(options::OPT_fpie))) {
5517 CmdArgs.push_back("-KPIC");
5518 }
Rafael Espindola92b00932010-08-10 00:25:48 +00005519 }
5520
5521 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5522 options::OPT_Xassembler);
5523
5524 CmdArgs.push_back("-o");
5525 CmdArgs.push_back(Output.getFilename());
5526
5527 for (InputInfoList::const_iterator
5528 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5529 const InputInfo &II = *it;
5530 CmdArgs.push_back(II.getFilename());
5531 }
5532
5533 const char *Exec =
5534 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5535 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5536}
5537
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005538static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5539 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00005540 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Logan Chien3d3373c2012-11-19 12:04:11 +00005541 bool StaticLibgcc = Args.hasArg(options::OPT_static) ||
5542 Args.hasArg(options::OPT_static_libgcc);
Rafael Espindolacc354322011-10-17 21:39:04 +00005543 if (!D.CCCIsCXX)
5544 CmdArgs.push_back("-lgcc");
5545
Logan Chien3d3373c2012-11-19 12:04:11 +00005546 if (StaticLibgcc || isAndroid) {
Rafael Espindolacc354322011-10-17 21:39:04 +00005547 if (D.CCCIsCXX)
5548 CmdArgs.push_back("-lgcc");
5549 } else {
5550 if (!D.CCCIsCXX)
5551 CmdArgs.push_back("--as-needed");
5552 CmdArgs.push_back("-lgcc_s");
5553 if (!D.CCCIsCXX)
5554 CmdArgs.push_back("--no-as-needed");
5555 }
5556
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005557 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00005558 CmdArgs.push_back("-lgcc_eh");
5559 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
5560 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00005561
5562 // According to Android ABI, we have to link with libdl if we are
5563 // linking with non-static libgcc.
5564 //
5565 // NOTE: This fixes a link error on Android MIPS as well. The non-static
5566 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
5567 if (isAndroid && !StaticLibgcc)
5568 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00005569}
5570
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005571static bool hasMipsN32ABIArg(const ArgList &Args) {
5572 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
Richard Smithbd55daf2012-11-01 04:30:05 +00005573 return A && (A->getValue() == StringRef("n32"));
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005574}
5575
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005576void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
5577 const InputInfo &Output,
5578 const InputInfoList &Inputs,
5579 const ArgList &Args,
5580 const char *LinkingOutput) const {
5581 const toolchains::Linux& ToolChain =
5582 static_cast<const toolchains::Linux&>(getToolChain());
5583 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00005584 const bool isAndroid =
5585 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005586
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005587 ArgStringList CmdArgs;
5588
Rafael Espindolad1002f62010-11-15 18:28:16 +00005589 // Silence warning for "clang -g foo.o -o foo"
5590 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005591 // and "clang -emit-llvm foo.o -o foo"
5592 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00005593 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00005594 // handled somewhere else.
5595 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00005596
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005597 if (!D.SysRoot.empty())
5598 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005599
Peter Collingbourne24c67c62013-01-17 20:17:16 +00005600 if (Args.hasArg(options::OPT_pie) && !Args.hasArg(options::OPT_shared))
Rafael Espindolad47ac232010-11-17 22:26:15 +00005601 CmdArgs.push_back("-pie");
5602
Rafael Espindola1c76c592010-11-07 22:57:16 +00005603 if (Args.hasArg(options::OPT_rdynamic))
5604 CmdArgs.push_back("-export-dynamic");
5605
Rafael Espindola34d77dc2010-11-11 19:34:42 +00005606 if (Args.hasArg(options::OPT_s))
5607 CmdArgs.push_back("-s");
5608
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005609 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
5610 e = ToolChain.ExtraOpts.end();
5611 i != e; ++i)
5612 CmdArgs.push_back(i->c_str());
5613
5614 if (!Args.hasArg(options::OPT_static)) {
5615 CmdArgs.push_back("--eh-frame-hdr");
5616 }
5617
5618 CmdArgs.push_back("-m");
5619 if (ToolChain.getArch() == llvm::Triple::x86)
5620 CmdArgs.push_back("elf_i386");
Tim Northover9bb857a2013-01-31 12:13:10 +00005621 else if (ToolChain.getArch() == llvm::Triple::aarch64)
5622 CmdArgs.push_back("aarch64linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005623 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00005624 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005625 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005626 else if (ToolChain.getArch() == llvm::Triple::ppc)
5627 CmdArgs.push_back("elf32ppclinux");
5628 else if (ToolChain.getArch() == llvm::Triple::ppc64)
5629 CmdArgs.push_back("elf64ppc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005630 else if (ToolChain.getArch() == llvm::Triple::mips)
5631 CmdArgs.push_back("elf32btsmip");
5632 else if (ToolChain.getArch() == llvm::Triple::mipsel)
5633 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005634 else if (ToolChain.getArch() == llvm::Triple::mips64) {
5635 if (hasMipsN32ABIArg(Args))
5636 CmdArgs.push_back("elf32btsmipn32");
5637 else
5638 CmdArgs.push_back("elf64btsmip");
5639 }
5640 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
5641 if (hasMipsN32ABIArg(Args))
5642 CmdArgs.push_back("elf32ltsmipn32");
5643 else
5644 CmdArgs.push_back("elf64ltsmip");
5645 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005646 else
5647 CmdArgs.push_back("elf_x86_64");
5648
5649 if (Args.hasArg(options::OPT_static)) {
Douglas Gregord9bb1522011-03-06 19:11:49 +00005650 if (ToolChain.getArch() == llvm::Triple::arm
5651 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005652 CmdArgs.push_back("-Bstatic");
5653 else
5654 CmdArgs.push_back("-static");
5655 } else if (Args.hasArg(options::OPT_shared)) {
5656 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00005657 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005658 CmdArgs.push_back("-Bsymbolic");
5659 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005660 }
5661
5662 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00005663 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005664 (!Args.hasArg(options::OPT_static) &&
5665 !Args.hasArg(options::OPT_shared))) {
5666 CmdArgs.push_back("-dynamic-linker");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005667 if (isAndroid)
5668 CmdArgs.push_back("/system/bin/linker");
5669 else if (ToolChain.getArch() == llvm::Triple::x86)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005670 CmdArgs.push_back("/lib/ld-linux.so.2");
Tim Northover9bb857a2013-01-31 12:13:10 +00005671 else if (ToolChain.getArch() == llvm::Triple::aarch64)
5672 CmdArgs.push_back("/lib/ld-linux-aarch64.so.1");
Douglas Gregord9bb1522011-03-06 19:11:49 +00005673 else if (ToolChain.getArch() == llvm::Triple::arm ||
Jiangning Liueabbf922012-07-30 11:05:56 +00005674 ToolChain.getArch() == llvm::Triple::thumb) {
5675 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
5676 CmdArgs.push_back("/lib/ld-linux-armhf.so.3");
5677 else
5678 CmdArgs.push_back("/lib/ld-linux.so.3");
5679 }
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005680 else if (ToolChain.getArch() == llvm::Triple::mips ||
5681 ToolChain.getArch() == llvm::Triple::mipsel)
5682 CmdArgs.push_back("/lib/ld.so.1");
Simon Atanasyan1e1e2e22012-04-06 20:14:27 +00005683 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005684 ToolChain.getArch() == llvm::Triple::mips64el) {
5685 if (hasMipsN32ABIArg(Args))
5686 CmdArgs.push_back("/lib32/ld.so.1");
5687 else
5688 CmdArgs.push_back("/lib64/ld.so.1");
5689 }
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005690 else if (ToolChain.getArch() == llvm::Triple::ppc)
Chris Lattner20b90d02011-04-11 21:15:37 +00005691 CmdArgs.push_back("/lib/ld.so.1");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005692 else if (ToolChain.getArch() == llvm::Triple::ppc64)
Chris Lattner20b90d02011-04-11 21:15:37 +00005693 CmdArgs.push_back("/lib64/ld64.so.1");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005694 else
5695 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
5696 }
5697
5698 CmdArgs.push_back("-o");
5699 CmdArgs.push_back(Output.getFilename());
5700
Rafael Espindola81937ec2010-12-01 01:52:43 +00005701 if (!Args.hasArg(options::OPT_nostdlib) &&
5702 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005703 if (!isAndroid) {
5704 const char *crt1 = NULL;
5705 if (!Args.hasArg(options::OPT_shared)){
5706 if (Args.hasArg(options::OPT_pie))
5707 crt1 = "Scrt1.o";
5708 else
5709 crt1 = "crt1.o";
5710 }
5711 if (crt1)
5712 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005713
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005714 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5715 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005716
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005717 const char *crtbegin;
5718 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005719 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005720 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005721 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005722 else if (Args.hasArg(options::OPT_pie))
5723 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005724 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005725 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005726 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00005727
5728 // Add crtfastmath.o if available and fast math is enabled.
5729 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005730 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005731
5732 Args.AddAllArgs(CmdArgs, options::OPT_L);
5733
5734 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5735
Roman Divackyee8188a2011-03-01 17:53:14 +00005736 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5737 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005738 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005739
Rafael Espindola9446d762012-04-09 23:53:34 +00005740 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5741 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5742 // forward.
5743 if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) {
5744 CmdArgs.push_back("-plugin");
5745 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5746 CmdArgs.push_back(Args.MakeArgString(Plugin));
Chandler Carruth953fb082013-01-13 11:46:33 +00005747
5748 // Try to pass driver level flags relevant to LTO code generation down to
5749 // the plugin.
5750
5751 // Handle architecture-specific flags for selecting CPU variants.
5752 if (ToolChain.getArch() == llvm::Triple::x86 ||
5753 ToolChain.getArch() == llvm::Triple::x86_64)
5754 CmdArgs.push_back(
5755 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5756 getX86TargetCPU(Args, ToolChain.getTriple())));
5757 else if (ToolChain.getArch() == llvm::Triple::arm ||
5758 ToolChain.getArch() == llvm::Triple::thumb)
5759 CmdArgs.push_back(
5760 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5761 getARMTargetCPU(Args, ToolChain.getTriple())));
5762
5763 // FIXME: Factor out logic for MIPS, PPC, and other targets to support this
5764 // as well.
Rafael Espindola9446d762012-04-09 23:53:34 +00005765 }
5766
Chandler Carruth953fb082013-01-13 11:46:33 +00005767
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00005768 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5769 CmdArgs.push_back("--no-demangle");
5770
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005771 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5772
Alexey Samsonov627b10f2012-11-06 15:09:03 +00005773 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00005774
Eric Christopher04997782012-11-29 18:51:05 +00005775 // Call these before we add the C++ ABI library.
Richard Smith52be6192012-11-05 22:04:41 +00005776 if (Sanitize.needsUbsanRt())
5777 addUbsanRTLinux(getToolChain(), Args, CmdArgs);
Eric Christopher04997782012-11-29 18:51:05 +00005778 if (Sanitize.needsAsanRt())
5779 addAsanRTLinux(getToolChain(), Args, CmdArgs);
5780 if (Sanitize.needsTsanRt())
5781 addTsanRTLinux(getToolChain(), Args, CmdArgs);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00005782 if (Sanitize.needsMsanRt())
5783 addMsanRTLinux(getToolChain(), Args, CmdArgs);
Richard Smith4d3110a2012-10-25 02:14:12 +00005784
Chandler Carruth94a32012012-05-14 18:31:18 +00005785 if (D.CCCIsCXX &&
5786 !Args.hasArg(options::OPT_nostdlib) &&
5787 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00005788 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
5789 !Args.hasArg(options::OPT_static);
5790 if (OnlyLibstdcxxStatic)
5791 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005792 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00005793 if (OnlyLibstdcxxStatic)
5794 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005795 CmdArgs.push_back("-lm");
5796 }
5797
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005798 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00005799 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
5800 if (Args.hasArg(options::OPT_static))
5801 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00005802
Chandler Carruth01538002013-01-17 13:19:29 +00005803 bool OpenMP = Args.hasArg(options::OPT_fopenmp);
5804 if (OpenMP) {
5805 CmdArgs.push_back("-lgomp");
5806
5807 // FIXME: Exclude this for platforms whith libgomp that doesn't require
5808 // librt. Most modern Linux platfroms require it, but some may not.
5809 CmdArgs.push_back("-lrt");
5810 }
5811
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005812 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005813
Chandler Carruth94a32012012-05-14 18:31:18 +00005814 if (Args.hasArg(options::OPT_pthread) ||
Chandler Carruth01538002013-01-17 13:19:29 +00005815 Args.hasArg(options::OPT_pthreads) || OpenMP)
Chandler Carruth94a32012012-05-14 18:31:18 +00005816 CmdArgs.push_back("-lpthread");
5817
5818 CmdArgs.push_back("-lc");
5819
5820 if (Args.hasArg(options::OPT_static))
5821 CmdArgs.push_back("--end-group");
5822 else
5823 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5824 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00005825
Rafael Espindola81937ec2010-12-01 01:52:43 +00005826 if (!Args.hasArg(options::OPT_nostartfiles)) {
5827 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005828 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005829 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00005830 else if (Args.hasArg(options::OPT_pie))
5831 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00005832 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005833 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00005834
Rafael Espindola81937ec2010-12-01 01:52:43 +00005835 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005836 if (!isAndroid)
5837 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00005838 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005839 }
5840
Bill Wendling08760582011-06-27 19:15:03 +00005841 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005842
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005843 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
5844}
Rafael Espindola92b00932010-08-10 00:25:48 +00005845
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00005846void linuxtools::SplitDebug::ConstructJob(Compilation &C, const JobAction &JA,
5847 const InputInfo &Output,
5848 const InputInfoList &Inputs,
5849 const ArgList &Args,
5850 const char *LinkingOutput) const {
5851 // Assert some invariants.
5852 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5853 const InputInfo &Input = Inputs[0];
5854 assert(Input.isFilename() && "Unexpected verify input");
5855
5856 ArgStringList ExtractArgs;
5857 ExtractArgs.push_back("--extract-dwo");
5858
5859 ArgStringList StripArgs;
5860 StripArgs.push_back("--strip-dwo");
5861
5862 // Grabbing the output of the earlier compile step.
5863 StripArgs.push_back(Input.getFilename());
5864 ExtractArgs.push_back(Input.getFilename());
5865
5866 // Add an output for the extract.
5867 SmallString<128> T(Inputs[0].getBaseInput());
5868 llvm::sys::path::replace_extension(T, "dwo");
5869 const char *OutFile = Args.MakeArgString(T);
5870 ExtractArgs.push_back(OutFile);
5871
5872 const char *Exec =
5873 Args.MakeArgString(getToolChain().GetProgramPath("objcopy"));
5874
5875 // First extract the dwo sections.
5876 C.addCommand(new Command(JA, *this, Exec, ExtractArgs));
5877
5878 // Then remove them from the original .o file.
5879 C.addCommand(new Command(JA, *this, Exec, StripArgs));
5880}
5881
Chris Lattner3e2ee142010-07-07 16:01:42 +00005882void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005883 const InputInfo &Output,
5884 const InputInfoList &Inputs,
5885 const ArgList &Args,
5886 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005887 ArgStringList CmdArgs;
5888
5889 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5890 options::OPT_Xassembler);
5891
5892 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005893 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00005894
5895 for (InputInfoList::const_iterator
5896 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5897 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005898 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00005899 }
5900
5901 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00005902 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005903 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005904}
5905
5906void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005907 const InputInfo &Output,
5908 const InputInfoList &Inputs,
5909 const ArgList &Args,
5910 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005911 const Driver &D = getToolChain().getDriver();
5912 ArgStringList CmdArgs;
5913
Daniel Dunbarb440f562010-08-02 02:38:21 +00005914 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005915 CmdArgs.push_back("-o");
5916 CmdArgs.push_back(Output.getFilename());
5917 } else {
5918 assert(Output.isNothing() && "Invalid output.");
5919 }
5920
5921 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00005922 !Args.hasArg(options::OPT_nostartfiles)) {
5923 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
5924 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5925 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
5926 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
5927 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005928
5929 Args.AddAllArgs(CmdArgs, options::OPT_L);
5930 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5931 Args.AddAllArgs(CmdArgs, options::OPT_e);
5932
Daniel Dunbar54423b22010-09-17 00:24:54 +00005933 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00005934
Eli Friedman83de5132011-12-08 23:54:21 +00005935 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5936
Chris Lattner3e2ee142010-07-07 16:01:42 +00005937 if (!Args.hasArg(options::OPT_nostdlib) &&
5938 !Args.hasArg(options::OPT_nodefaultlibs)) {
5939 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005940 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00005941 CmdArgs.push_back("-lm");
5942 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005943 }
5944
5945 if (!Args.hasArg(options::OPT_nostdlib) &&
5946 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00005947 if (Args.hasArg(options::OPT_pthread))
5948 CmdArgs.push_back("-lpthread");
5949 CmdArgs.push_back("-lc");
5950 CmdArgs.push_back("-lCompilerRT-Generic");
5951 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
5952 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00005953 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005954 }
5955
Eli Friedman83de5132011-12-08 23:54:21 +00005956 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005957 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005958}
5959
Daniel Dunbarcc912342009-05-02 18:28:39 +00005960/// DragonFly Tools
5961
5962// For now, DragonFly Assemble does just about the same as for
5963// FreeBSD, but this may change soon.
5964void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005965 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005966 const InputInfoList &Inputs,
5967 const ArgList &Args,
5968 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00005969 ArgStringList CmdArgs;
5970
5971 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5972 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005973 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00005974 CmdArgs.push_back("--32");
5975
5976 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5977 options::OPT_Xassembler);
5978
5979 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005980 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00005981
5982 for (InputInfoList::const_iterator
5983 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5984 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005985 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00005986 }
5987
5988 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005989 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005990 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00005991}
5992
5993void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005994 const InputInfo &Output,
5995 const InputInfoList &Inputs,
5996 const ArgList &Args,
5997 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005998 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00005999 ArgStringList CmdArgs;
6000
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006001 if (!D.SysRoot.empty())
6002 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6003
Daniel Dunbarcc912342009-05-02 18:28:39 +00006004 if (Args.hasArg(options::OPT_static)) {
6005 CmdArgs.push_back("-Bstatic");
6006 } else {
6007 if (Args.hasArg(options::OPT_shared))
6008 CmdArgs.push_back("-Bshareable");
6009 else {
6010 CmdArgs.push_back("-dynamic-linker");
6011 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6012 }
6013 }
6014
6015 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6016 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006017 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00006018 CmdArgs.push_back("-m");
6019 CmdArgs.push_back("elf_i386");
6020 }
6021
Daniel Dunbarb440f562010-08-02 02:38:21 +00006022 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00006023 CmdArgs.push_back("-o");
6024 CmdArgs.push_back(Output.getFilename());
6025 } else {
6026 assert(Output.isNothing() && "Invalid output.");
6027 }
6028
6029 if (!Args.hasArg(options::OPT_nostdlib) &&
6030 !Args.hasArg(options::OPT_nostartfiles)) {
6031 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006032 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006033 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006034 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006035 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006036 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006037 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006038 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006039 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006040 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006041 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006042 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006043 }
6044 }
6045
6046 Args.AddAllArgs(CmdArgs, options::OPT_L);
6047 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6048 Args.AddAllArgs(CmdArgs, options::OPT_e);
6049
Daniel Dunbar54423b22010-09-17 00:24:54 +00006050 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00006051
6052 if (!Args.hasArg(options::OPT_nostdlib) &&
6053 !Args.hasArg(options::OPT_nodefaultlibs)) {
6054 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6055 // rpaths
6056 CmdArgs.push_back("-L/usr/lib/gcc41");
6057
6058 if (!Args.hasArg(options::OPT_static)) {
6059 CmdArgs.push_back("-rpath");
6060 CmdArgs.push_back("/usr/lib/gcc41");
6061
6062 CmdArgs.push_back("-rpath-link");
6063 CmdArgs.push_back("/usr/lib/gcc41");
6064
6065 CmdArgs.push_back("-rpath");
6066 CmdArgs.push_back("/usr/lib");
6067
6068 CmdArgs.push_back("-rpath-link");
6069 CmdArgs.push_back("/usr/lib");
6070 }
6071
Rafael Espindola38360b32010-07-20 12:59:03 +00006072 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006073 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00006074 CmdArgs.push_back("-lm");
6075 }
6076
Daniel Dunbarcc912342009-05-02 18:28:39 +00006077 if (Args.hasArg(options::OPT_shared)) {
6078 CmdArgs.push_back("-lgcc_pic");
6079 } else {
6080 CmdArgs.push_back("-lgcc");
6081 }
6082
6083
6084 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00006085 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00006086
6087 if (!Args.hasArg(options::OPT_nolibc)) {
6088 CmdArgs.push_back("-lc");
6089 }
6090
6091 if (Args.hasArg(options::OPT_shared)) {
6092 CmdArgs.push_back("-lgcc_pic");
6093 } else {
6094 CmdArgs.push_back("-lgcc");
6095 }
6096 }
6097
6098 if (!Args.hasArg(options::OPT_nostdlib) &&
6099 !Args.hasArg(options::OPT_nostartfiles)) {
6100 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006101 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006102 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006103 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006104 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006105 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006106 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006107 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006108 }
6109
Bill Wendling08760582011-06-27 19:15:03 +00006110 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006111
Daniel Dunbarcc912342009-05-02 18:28:39 +00006112 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006113 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006114 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006115}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006116
6117void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6118 const InputInfo &Output,
6119 const InputInfoList &Inputs,
6120 const ArgList &Args,
6121 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006122 ArgStringList CmdArgs;
6123
6124 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00006125 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6126 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006127 } else {
6128 assert(Output.isNothing() && "Invalid output.");
6129 }
6130
6131 if (!Args.hasArg(options::OPT_nostdlib) &&
6132 !Args.hasArg(options::OPT_nostartfiles)) {
6133 CmdArgs.push_back("-defaultlib:libcmt");
6134 }
6135
6136 CmdArgs.push_back("-nologo");
6137
Michael J. Spencere2f49362012-06-18 16:56:04 +00006138 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6139
6140 // Add filenames immediately.
6141 for (InputInfoList::const_iterator
6142 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6143 if (it->isFilename())
6144 CmdArgs.push_back(it->getFilename());
6145 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006146
6147 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00006148 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006149 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6150}