blob: 8763f7aa77a0c1ee76ba04fc8ed4bbe020ad78db [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
11
Daniel Dunbara2aedc62009-03-18 10:01:51 +000012#include "clang/Driver/Action.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000013#include "clang/Driver/Arg.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000014#include "clang/Driver/ArgList.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000015#include "clang/Driver/Driver.h"
16#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000017#include "clang/Driver/Compilation.h"
18#include "clang/Driver/Job.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000019#include "clang/Driver/Option.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000020#include "clang/Driver/Options.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000021#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000022#include "clang/Driver/Util.h"
John McCall5fb5df92012-06-20 06:18:46 +000023#include "clang/Basic/ObjCRuntime.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000024
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000026#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000027#include "llvm/ADT/Twine.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000028#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000029#include "llvm/Support/Format.h"
30#include "llvm/Support/raw_ostream.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000031#include "llvm/Support/Host.h"
32#include "llvm/Support/Process.h"
John McCall31168b02011-06-15 23:02:42 +000033#include "llvm/Support/ErrorHandling.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000034
35#include "InputInfo.h"
Alexey Samsonov627b10f2012-11-06 15:09:03 +000036#include "SanitizerArgs.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000037#include "ToolChains.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000038
Daniel Dunbar1a093d22009-03-18 06:00:36 +000039using namespace clang::driver;
40using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000041using namespace clang;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000042
Daniel Dunbar64198ef2009-09-10 01:21:05 +000043/// CheckPreprocessingOptions - Perform some validation of preprocessing
44/// arguments that is shared with gcc.
45static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
46 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +000047 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
Chris Lattner0e62c1c2011-07-23 10:55:15 +000048 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar64198ef2009-09-10 01:21:05 +000049 << A->getAsString(Args) << "-E";
50}
51
Daniel Dunbar4eadb602009-09-10 01:21:12 +000052/// CheckCodeGenerationOptions - Perform some validation of code generation
53/// arguments that is shared with gcc.
54static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
55 // In gcc, only ARM checks this, but it seems reasonable to check universally.
56 if (Args.hasArg(options::OPT_static))
57 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
58 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000059 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000060 << A->getAsString(Args) << "-static";
61}
62
Chris Lattnerbf2803f2010-03-29 17:55:58 +000063// Quote target names for inclusion in GNU Make dependency files.
64// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000065static void QuoteTarget(StringRef Target,
66 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000067 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
68 switch (Target[i]) {
69 case ' ':
70 case '\t':
71 // Escape the preceding backslashes
72 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
73 Res.push_back('\\');
74
75 // Escape the space/tab
76 Res.push_back('\\');
77 break;
78 case '$':
79 Res.push_back('$');
80 break;
81 case '#':
82 Res.push_back('\\');
83 break;
84 default:
85 break;
86 }
87
88 Res.push_back(Target[i]);
89 }
90}
91
Bill Wendlingc0938f32012-03-12 22:10:06 +000092static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +000093 ArgStringList &CmdArgs,
94 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +000095 const char *EnvVar) {
96 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +000097 bool CombinedArg = false;
98
Bill Wendling281ca292012-03-12 21:22:35 +000099 if (!DirList)
100 return; // Nothing to do.
101
Chad Rosier616e8a52012-10-30 21:42:09 +0000102 StringRef Name(ArgName);
103 if (Name.equals("-I") || Name.equals("-L"))
104 CombinedArg = true;
105
Bill Wendling281ca292012-03-12 21:22:35 +0000106 StringRef Dirs(DirList);
107 if (Dirs.empty()) // Empty string should not add '.'.
108 return;
109
110 StringRef::size_type Delim;
111 while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
112 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000113 if (CombinedArg) {
114 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
115 } else {
116 CmdArgs.push_back(ArgName);
117 CmdArgs.push_back(".");
118 }
Bill Wendling281ca292012-03-12 21:22:35 +0000119 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000120 if (CombinedArg) {
121 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
122 } else {
123 CmdArgs.push_back(ArgName);
124 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
125 }
Bill Wendling281ca292012-03-12 21:22:35 +0000126 }
Nico Weber89355782012-03-19 15:00:03 +0000127 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000128 }
129
130 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000131 if (CombinedArg) {
132 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
133 } else {
134 CmdArgs.push_back(ArgName);
135 CmdArgs.push_back(".");
136 }
Bill Wendling281ca292012-03-12 21:22:35 +0000137 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000138 if (CombinedArg) {
139 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
140 } else {
141 CmdArgs.push_back(ArgName);
142 CmdArgs.push_back(Args.MakeArgString(Dirs));
143 }
Bill Wendling281ca292012-03-12 21:22:35 +0000144 }
145}
146
Daniel Dunbar54423b22010-09-17 00:24:54 +0000147static void AddLinkerInputs(const ToolChain &TC,
148 const InputInfoList &Inputs, const ArgList &Args,
149 ArgStringList &CmdArgs) {
150 const Driver &D = TC.getDriver();
151
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000152 // Add extra linker input arguments which are not treated as inputs
153 // (constructed via -Xarch_).
154 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
155
Daniel Dunbar54423b22010-09-17 00:24:54 +0000156 for (InputInfoList::const_iterator
157 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
158 const InputInfo &II = *it;
159
160 if (!TC.HasNativeLLVMSupport()) {
161 // Don't try to pass LLVM inputs unless we have native support.
162 if (II.getType() == types::TY_LLVM_IR ||
163 II.getType() == types::TY_LTO_IR ||
164 II.getType() == types::TY_LLVM_BC ||
165 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000166 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000167 << TC.getTripleString();
168 }
169
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000170 // Add filenames immediately.
171 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000172 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000173 continue;
174 }
175
176 // Otherwise, this is a linker input argument.
177 const Arg &A = II.getInputArg();
178
179 // Handle reserved library options.
180 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000181 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000182 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
183 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000184 } else
185 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000186 }
Bill Wendling281ca292012-03-12 21:22:35 +0000187
188 // LIBRARY_PATH - included following the user specified library paths.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000189 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000190}
191
John McCall31168b02011-06-15 23:02:42 +0000192/// \brief Determine whether Objective-C automated reference counting is
193/// enabled.
194static bool isObjCAutoRefCount(const ArgList &Args) {
195 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
196}
197
Ted Kremeneke65b0862012-03-06 20:05:56 +0000198/// \brief Determine whether we are linking the ObjC runtime.
199static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000200 if (isObjCAutoRefCount(Args)) {
201 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000202 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000203 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000204 return Args.hasArg(options::OPT_fobjc_link_runtime);
205}
206
Rafael Espindola9d4a8cf2011-06-02 18:58:46 +0000207static void addProfileRT(const ToolChain &TC, const ArgList &Args,
Bill Wendling08760582011-06-27 19:15:03 +0000208 ArgStringList &CmdArgs,
209 llvm::Triple Triple) {
210 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
211 Args.hasArg(options::OPT_fprofile_generate) ||
212 Args.hasArg(options::OPT_fcreate_profile) ||
213 Args.hasArg(options::OPT_coverage)))
214 return;
215
216 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
217 // the link line. We cannot do the same thing because unlike gcov there is a
218 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
219 // not supported by old linkers.
Benjamin Kramerf5fbe432011-11-07 16:02:25 +0000220 std::string ProfileRT =
221 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
Bill Wendling08760582011-06-27 19:15:03 +0000222
Bill Wendling08760582011-06-27 19:15:03 +0000223 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
Rafael Espindola9d4a8cf2011-06-02 18:58:46 +0000224}
225
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000226static bool forwardToGCC(const Option &O) {
227 return !O.hasFlag(options::NoForward) &&
228 !O.hasFlag(options::DriverOption) &&
229 !O.hasFlag(options::LinkerInput);
230}
231
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000232void Clang::AddPreprocessingOptions(Compilation &C,
233 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000234 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000235 ArgStringList &CmdArgs,
236 const InputInfo &Output,
237 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000238 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000239
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000240 CheckPreprocessingOptions(D, Args);
241
242 Args.AddLastArg(CmdArgs, options::OPT_C);
243 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000244
245 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000246 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000247 (A = Args.getLastArg(options::OPT_MD)) ||
248 (A = Args.getLastArg(options::OPT_MMD))) {
249 // Determine the output location.
250 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000251 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000252 DepFile = MF->getValue();
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000253 C.addFailureResultFile(DepFile);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000254 } else if (Output.getType() == types::TY_Dependencies) {
255 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000256 } else if (A->getOption().matches(options::OPT_M) ||
257 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000258 DepFile = "-";
259 } else {
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +0000260 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000261 C.addFailureResultFile(DepFile);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000262 }
263 CmdArgs.push_back("-dependency-file");
264 CmdArgs.push_back(DepFile);
265
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000266 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000267 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
268 const char *DepTarget;
269
270 // If user provided -o, that is the dependency target, except
271 // when we are only generating a dependency file.
272 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
273 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000274 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000275 } else {
276 // Otherwise derive from the base input.
277 //
278 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000279 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000280 llvm::sys::path::replace_extension(P, "o");
281 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000282 }
283
284 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000285 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000286 QuoteTarget(DepTarget, Quoted);
287 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000288 }
289
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000290 if (A->getOption().matches(options::OPT_M) ||
291 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000292 CmdArgs.push_back("-sys-header-deps");
293 }
294
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000295 if (Args.hasArg(options::OPT_MG)) {
296 if (!A || A->getOption().matches(options::OPT_MD) ||
297 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000298 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000299 CmdArgs.push_back("-MG");
300 }
301
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000302 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000303
304 // Convert all -MQ <target> args to -MT <quoted target>
305 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
306 options::OPT_MQ),
307 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000308 const Arg *A = *it;
309 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000310
Daniel Dunbara442fd52010-06-11 22:00:13 +0000311 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000312 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000313 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000314 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000315 CmdArgs.push_back(Args.MakeArgString(Quoted));
316
317 // -MT flag - no change
318 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000319 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000320 }
321 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000322
Douglas Gregor111af7d2009-04-18 00:34:01 +0000323 // Add -i* options, and automatically translate to
324 // -include-pch/-include-pth for transparent PCH support. It's
325 // wonky, but we include looking for .gch so we can support seamless
326 // replacement into a build system already set up to be generating
327 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000328 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000329 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
330 ie = Args.filtered_end(); it != ie; ++it) {
331 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000332
333 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000334 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
335 RenderedImplicitInclude = true;
336
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000337 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000338 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000339
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000340 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000341 bool FoundPCH = false;
Richard Smithbd55daf2012-11-01 04:30:05 +0000342 llvm::sys::Path P(A->getValue());
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000343 bool Exists;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000344 if (UsePCH) {
Douglas Gregor111af7d2009-04-18 00:34:01 +0000345 P.appendSuffix("pch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000346 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000347 FoundPCH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000348 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000349 P.eraseSuffix();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000350 }
351
Douglas Gregor111af7d2009-04-18 00:34:01 +0000352 if (!FoundPCH) {
353 P.appendSuffix("pth");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000354 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Douglas Gregor111af7d2009-04-18 00:34:01 +0000355 FoundPTH = true;
356 else
357 P.eraseSuffix();
Mike Stump11289f42009-09-09 15:08:12 +0000358 }
359
Douglas Gregor111af7d2009-04-18 00:34:01 +0000360 if (!FoundPCH && !FoundPTH) {
361 P.appendSuffix("gch");
Michael J. Spencerf6efe582011-01-10 02:34:13 +0000362 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000363 FoundPCH = UsePCH;
364 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000365 }
Mike Stump11289f42009-09-09 15:08:12 +0000366 else
Douglas Gregor111af7d2009-04-18 00:34:01 +0000367 P.eraseSuffix();
368 }
369
370 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000371 if (IsFirstImplicitInclude) {
372 A->claim();
373 if (UsePCH)
374 CmdArgs.push_back("-include-pch");
375 else
376 CmdArgs.push_back("-include-pth");
377 CmdArgs.push_back(Args.MakeArgString(P.str()));
378 continue;
379 } else {
380 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000381 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000382 << P.str() << A->getAsString(Args);
383 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000384 }
385 }
386
387 // Not translated, render as usual.
388 A->claim();
389 A->render(Args, CmdArgs);
390 }
391
392 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000393 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
394 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000395
396 // Add -Wp, and -Xassembler if using the preprocessor.
397
398 // FIXME: There is a very unfortunate problem here, some troubled
399 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
400 // really support that we would have to parse and then translate
401 // those options. :(
402 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
403 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000404
405 // -I- is a deprecated GCC feature, reject it.
406 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000407 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000408
409 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
410 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000411 StringRef sysroot = C.getSysRoot();
412 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000413 if (!Args.hasArg(options::OPT_isysroot)) {
414 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000415 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000416 }
417 }
Douglas Gregorf936f782011-09-14 20:28:46 +0000418
419 // If a module path was provided, pass it along. Otherwise, use a temporary
420 // directory.
421 if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) {
Douglas Gregorf936f782011-09-14 20:28:46 +0000422 A->claim();
423 A->render(Args, CmdArgs);
424 } else {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000425 SmallString<128> DefaultModuleCache;
Douglas Gregorf936f782011-09-14 20:28:46 +0000426 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
427 DefaultModuleCache);
428 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
429 CmdArgs.push_back("-fmodule-cache-path");
430 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
431 }
Douglas Gregor97eec242011-09-15 22:00:41 +0000432
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000433 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000434 // FIXME: We should probably sink the logic for handling these from the
435 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000436 // CPATH - included following the user specified includes (but prior to
437 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000438 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000439 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000440 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000441 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000442 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000443 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000444 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000445 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000446 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000447
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000448 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000449 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000450 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000451
452 // Add system include arguments.
453 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000454}
455
Daniel Dunbarf492c922009-09-10 22:59:51 +0000456/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000457/// CPU.
458//
459// FIXME: This is redundant with -mcpu, why does LLVM use this.
460// FIXME: tblgen this, or kill it!
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000461static const char *getLLVMArchSuffixForARM(StringRef CPU) {
Chad Rosier9ac84512011-10-07 17:48:56 +0000462 return llvm::StringSwitch<const char *>(CPU)
463 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
464 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
465 .Cases("arm920", "arm920t", "arm922t", "v4t")
466 .Cases("arm940t", "ep9312","v4t")
467 .Cases("arm10tdmi", "arm1020t", "v5")
468 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
469 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
470 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
471 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
472 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
473 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Silviu Baranga157f7c62012-09-13 15:06:00 +0000474 .Cases("cortex-a8", "cortex-a9", "cortex-a15", "v7")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000475 .Case("cortex-m3", "v7m")
Jim Grosbach903e63f2012-03-29 19:53:34 +0000476 .Case("cortex-m4", "v7m")
Bob Wilson7f05ca32012-03-21 17:19:12 +0000477 .Case("cortex-m0", "v6m")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000478 .Case("cortex-a9-mp", "v7f")
479 .Case("swift", "v7s")
Chad Rosier9ac84512011-10-07 17:48:56 +0000480 .Default("");
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +0000481}
482
Benjamin Kramer09811c72012-06-26 22:20:06 +0000483/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
484//
485// FIXME: tblgen this.
486static std::string getARMTargetCPU(const ArgList &Args,
487 const llvm::Triple &Triple) {
488 // FIXME: Warn on inconsistent use of -mcpu and -march.
489
490 // If we have -mcpu=, use that.
491 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000492 StringRef MCPU = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000493 // Handle -mcpu=native.
494 if (MCPU == "native")
495 return llvm::sys::getHostCPUName();
496 else
497 return MCPU;
498 }
499
500 StringRef MArch;
501 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
502 // Otherwise, if we have -march= choose the base CPU for that arch.
Richard Smithbd55daf2012-11-01 04:30:05 +0000503 MArch = A->getValue();
Benjamin Kramer09811c72012-06-26 22:20:06 +0000504 } else {
505 // Otherwise, use the Arch from the triple.
506 MArch = Triple.getArchName();
507 }
508
509 // Handle -march=native.
510 std::string NativeMArch;
511 if (MArch == "native") {
512 std::string CPU = llvm::sys::getHostCPUName();
513 if (CPU != "generic") {
514 // Translate the native cpu into the architecture. The switch below will
515 // then chose the minimum cpu for that arch.
516 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
517 MArch = NativeMArch;
518 }
519 }
520
521 return llvm::StringSwitch<const char *>(MArch)
522 .Cases("armv2", "armv2a","arm2")
523 .Case("armv3", "arm6")
524 .Case("armv3m", "arm7m")
525 .Cases("armv4", "armv4t", "arm7tdmi")
526 .Cases("armv5", "armv5t", "arm10tdmi")
527 .Cases("armv5e", "armv5te", "arm1022e")
528 .Case("armv5tej", "arm926ej-s")
529 .Cases("armv6", "armv6k", "arm1136jf-s")
530 .Case("armv6j", "arm1136j-s")
531 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
532 .Case("armv6t2", "arm1156t2-s")
533 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
Bob Wilsond7cf1042012-09-29 23:52:50 +0000534 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
535 .Cases("armv7s", "armv7-s", "swift")
Benjamin Kramer09811c72012-06-26 22:20:06 +0000536 .Cases("armv7r", "armv7-r", "cortex-r4")
537 .Cases("armv7m", "armv7-m", "cortex-m3")
538 .Case("ep9312", "ep9312")
539 .Case("iwmmxt", "iwmmxt")
540 .Case("xscale", "xscale")
541 .Cases("armv6m", "armv6-m", "cortex-m0")
542 // If all else failed, return the most base CPU LLVM supports.
543 .Default("arm7tdmi");
544}
545
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000546// FIXME: Move to target hook.
547static bool isSignedCharDefault(const llvm::Triple &Triple) {
548 switch (Triple.getArch()) {
549 default:
550 return true;
551
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000552 case llvm::Triple::arm:
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000553 case llvm::Triple::ppc:
554 case llvm::Triple::ppc64:
Bob Wilson6524dd32011-10-14 05:03:44 +0000555 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000556 return true;
557 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000558 }
559}
560
Chad Rosiercfbfc582012-04-04 20:51:35 +0000561// Handle -mfpu=.
562//
563// FIXME: Centralize feature selection, defaulting shouldn't be also in the
564// frontend target.
565static void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args,
566 ArgStringList &CmdArgs) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000567 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000568
569 // Set the target features based on the FPU.
570 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
571 // Disable any default FPU support.
572 CmdArgs.push_back("-target-feature");
573 CmdArgs.push_back("-vfp2");
574 CmdArgs.push_back("-target-feature");
575 CmdArgs.push_back("-vfp3");
576 CmdArgs.push_back("-target-feature");
577 CmdArgs.push_back("-neon");
578 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
579 CmdArgs.push_back("-target-feature");
580 CmdArgs.push_back("+vfp3");
581 CmdArgs.push_back("-target-feature");
582 CmdArgs.push_back("+d16");
583 CmdArgs.push_back("-target-feature");
584 CmdArgs.push_back("-neon");
585 } else if (FPU == "vfp") {
586 CmdArgs.push_back("-target-feature");
587 CmdArgs.push_back("+vfp2");
588 CmdArgs.push_back("-target-feature");
589 CmdArgs.push_back("-neon");
590 } else if (FPU == "vfp3" || FPU == "vfpv3") {
591 CmdArgs.push_back("-target-feature");
592 CmdArgs.push_back("+vfp3");
593 CmdArgs.push_back("-target-feature");
594 CmdArgs.push_back("-neon");
595 } else if (FPU == "neon") {
596 CmdArgs.push_back("-target-feature");
597 CmdArgs.push_back("+neon");
598 } else
599 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
600}
601
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000602// Handle -mfpmath=.
603static void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args,
Chad Rosier45619cb2012-04-04 22:13:40 +0000604 ArgStringList &CmdArgs, StringRef CPU) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000605 StringRef FPMath = A->getValue();
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000606
607 // Set the target features based on the FPMath.
608 if (FPMath == "neon") {
609 CmdArgs.push_back("-target-feature");
610 CmdArgs.push_back("+neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000611
Silviu Baranga157f7c62012-09-13 15:06:00 +0000612 if (CPU != "cortex-a8" && CPU != "cortex-a9" && CPU != "cortex-a9-mp" &&
613 CPU != "cortex-a15")
Chad Rosier45619cb2012-04-04 22:13:40 +0000614 D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU;
615
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000616 } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" ||
617 FPMath == "vfp4") {
618 CmdArgs.push_back("-target-feature");
619 CmdArgs.push_back("-neonfp");
Chad Rosier45619cb2012-04-04 22:13:40 +0000620
621 // FIXME: Add warnings when disabling a feature not present for a given CPU.
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000622 } else
623 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
624}
625
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000626// Select the float ABI as determined by -msoft-float, -mhard-float, and
627// -mfloat-abi=.
628static StringRef getARMFloatABI(const Driver &D,
629 const ArgList &Args,
630 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000631 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000632 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
633 options::OPT_mhard_float,
634 options::OPT_mfloat_abi_EQ)) {
635 if (A->getOption().matches(options::OPT_msoft_float))
636 FloatABI = "soft";
637 else if (A->getOption().matches(options::OPT_mhard_float))
638 FloatABI = "hard";
639 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000640 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000641 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000642 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000643 << A->getAsString(Args);
644 FloatABI = "soft";
645 }
646 }
647 }
648
649 // If unspecified, choose the default based on the platform.
650 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000651 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000652 case llvm::Triple::Darwin:
653 case llvm::Triple::MacOSX:
654 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000655 // Darwin defaults to "softfp" for v6 and v7.
656 //
657 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000658 std::string ArchName =
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000659 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000660 if (StringRef(ArchName).startswith("v6") ||
661 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000662 FloatABI = "softfp";
663 else
664 FloatABI = "soft";
665 break;
666 }
667
668 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000669 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000670 case llvm::Triple::GNUEABIHF:
671 FloatABI = "hard";
672 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000673 case llvm::Triple::GNUEABI:
674 FloatABI = "softfp";
675 break;
676 case llvm::Triple::EABI:
677 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
678 FloatABI = "softfp";
679 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000680 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000681 std::string ArchName =
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000682 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000683 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000684 FloatABI = "softfp";
685 else
686 FloatABI = "soft";
687 break;
688 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000689 default:
690 // Assume "soft", but warn the user we are guessing.
691 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000692 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000693 break;
694 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000695 }
696 }
697
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000698 return FloatABI;
699}
700
701
702void Clang::AddARMTargetArgs(const ArgList &Args,
703 ArgStringList &CmdArgs,
704 bool KernelOrKext) const {
705 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000706 // Get the effective triple, which takes into account the deployment target.
707 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
708 llvm::Triple Triple(TripleStr);
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000709 std::string CPUName = getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000710
711 // Select the ABI to use.
712 //
713 // FIXME: Support -meabi.
714 const char *ABIName = 0;
715 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000716 ABIName = A->getValue();
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000717 } else if (Triple.isOSDarwin()) {
718 // The backend is hardwired to assume AAPCS for M-class processors, ensure
719 // the frontend matches that.
720 if (StringRef(CPUName).startswith("cortex-m")) {
721 ABIName = "aapcs";
722 } else {
723 ABIName = "apcs-gnu";
724 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000725 } else {
726 // Select the default based on the platform.
727 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000728 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000729 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000730 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000731 ABIName = "aapcs-linux";
732 break;
733 case llvm::Triple::EABI:
734 ABIName = "aapcs";
735 break;
736 default:
737 ABIName = "apcs-gnu";
738 }
739 }
740 CmdArgs.push_back("-target-abi");
741 CmdArgs.push_back(ABIName);
742
743 // Set the CPU based on -march= and -mcpu=.
744 CmdArgs.push_back("-target-cpu");
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000745 CmdArgs.push_back(Args.MakeArgString(CPUName));
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000746
747 // Determine floating point ABI from the options & target defaults.
748 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000749 if (FloatABI == "soft") {
750 // Floating point operations and argument passing are soft.
751 //
752 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000753 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000754 CmdArgs.push_back("-mfloat-abi");
755 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000756 } else if (FloatABI == "softfp") {
757 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000758 CmdArgs.push_back("-mfloat-abi");
759 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000760 } else {
761 // Floating point operations and argument passing are hard.
762 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000763 CmdArgs.push_back("-mfloat-abi");
764 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000765 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000766
767 // Set appropriate target features for floating point mode.
768 //
769 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
770 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
771 // stripped out by the ARM target.
772
773 // Use software floating point operations?
774 if (FloatABI == "soft") {
775 CmdArgs.push_back("-target-feature");
776 CmdArgs.push_back("+soft-float");
777 }
778
779 // Use software floating point argument passing?
780 if (FloatABI != "hard") {
781 CmdArgs.push_back("-target-feature");
782 CmdArgs.push_back("+soft-float-abi");
783 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +0000784
785 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +0000786 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +0000787 addFPUArgs(D, A, Args, CmdArgs);
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000788
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000789 // Honor -mfpmath=.
790 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +0000791 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Chad Rosier1f0e52e2012-04-04 20:39:32 +0000792
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000793 // Setting -msoft-float effectively disables NEON because of the GCC
794 // implementation, although the same isn't true of VFP or VFP3.
795 if (FloatABI == "soft") {
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000796 CmdArgs.push_back("-target-feature");
797 CmdArgs.push_back("-neon");
798 }
799
800 // Kernel code has more strict alignment requirements.
801 if (KernelOrKext) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000802 if (Triple.getOS() != llvm::Triple::IOS || Triple.isOSVersionLT(6)) {
803 CmdArgs.push_back("-backend-option");
804 CmdArgs.push_back("-arm-long-calls");
805 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000806
Daniel Dunbar12100e22011-03-22 16:48:17 +0000807 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000808 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000809
810 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000811 CmdArgs.push_back("-backend-option");
812 CmdArgs.push_back("-arm-darwin-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000813 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000814
815 // Setting -mno-global-merge disables the codegen global merge pass. Setting
816 // -mglobal-merge has no effect as the pass is enabled by default.
817 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
818 options::OPT_mno_global_merge)) {
819 if (A->getOption().matches(options::OPT_mno_global_merge))
820 CmdArgs.push_back("-mno-global-merge");
821 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000822
Chad Rosierc14ded72012-05-16 21:19:55 +0000823 if (Args.hasArg(options::OPT_mno_implicit_float))
Chad Rosierf1985d22012-05-16 20:40:09 +0000824 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000825}
826
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000827// Translate MIPS CPU name alias option to CPU name.
828static StringRef getMipsCPUFromAlias(const Arg &A) {
829 if (A.getOption().matches(options::OPT_mips32))
830 return "mips32";
831 if (A.getOption().matches(options::OPT_mips32r2))
832 return "mips32r2";
833 if (A.getOption().matches(options::OPT_mips64))
834 return "mips64";
835 if (A.getOption().matches(options::OPT_mips64r2))
836 return "mips64r2";
837 llvm_unreachable("Unexpected option");
838 return "";
839}
840
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000841// Get CPU and ABI names. They are not independent
842// so we have to calculate them together.
843static void getMipsCPUAndABI(const ArgList &Args,
844 const ToolChain &TC,
845 StringRef &CPUName,
846 StringRef &ABIName) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000847 const char *DefMips32CPU = "mips32";
848 const char *DefMips64CPU = "mips64";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000849
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000850 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000851 options::OPT_mcpu_EQ,
852 options::OPT_mips_CPUs_Group)) {
853 if (A->getOption().matches(options::OPT_mips_CPUs_Group))
854 CPUName = getMipsCPUFromAlias(*A);
855 else
Richard Smithbd55daf2012-11-01 04:30:05 +0000856 CPUName = A->getValue();
Simon Atanasyan2efe53e2012-09-21 20:19:32 +0000857 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000858
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000859 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000860 ABIName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000861
862 // Setup default CPU and ABI names.
863 if (CPUName.empty() && ABIName.empty()) {
864 switch (TC.getTriple().getArch()) {
865 default:
866 llvm_unreachable("Unexpected triple arch name");
867 case llvm::Triple::mips:
868 case llvm::Triple::mipsel:
869 CPUName = DefMips32CPU;
870 break;
871 case llvm::Triple::mips64:
872 case llvm::Triple::mips64el:
873 CPUName = DefMips64CPU;
874 break;
875 }
876 }
877
878 if (!ABIName.empty()) {
879 // Deduce CPU name from ABI name.
880 CPUName = llvm::StringSwitch<const char *>(ABIName)
881 .Cases("o32", "eabi", DefMips32CPU)
882 .Cases("n32", "n64", DefMips64CPU)
883 .Default("");
884 }
885 else if (!CPUName.empty()) {
886 // Deduce ABI name from CPU name.
887 ABIName = llvm::StringSwitch<const char *>(CPUName)
888 .Cases("mips32", "mips32r2", "o32")
889 .Cases("mips64", "mips64r2", "n64")
890 .Default("");
891 }
892
893 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000894}
895
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000896// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
897// and -mfloat-abi=.
898static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000899 // Select the float ABI as determined by -msoft-float, -mhard-float,
900 // and -mfloat-abi=.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000901 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000902 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000903 options::OPT_mhard_float,
904 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000905 if (A->getOption().matches(options::OPT_msoft_float))
906 FloatABI = "soft";
907 else if (A->getOption().matches(options::OPT_mhard_float))
908 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000909 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000910 FloatABI = A->getValue();
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000911 if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000912 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000913 FloatABI = "hard";
914 }
915 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000916 }
917
918 // If unspecified, choose the default based on the platform.
919 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000920 // Assume "hard", because it's a default value used by gcc.
921 // When we start to recognize specific target MIPS processors,
922 // we will be able to select the default more correctly.
923 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000924 }
925
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000926 return FloatABI;
927}
928
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000929static void AddTargetFeature(const ArgList &Args,
930 ArgStringList &CmdArgs,
931 OptSpecifier OnOpt,
932 OptSpecifier OffOpt,
933 StringRef FeatureName) {
934 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
935 CmdArgs.push_back("-target-feature");
936 if (A->getOption().matches(OnOpt))
937 CmdArgs.push_back(Args.MakeArgString("+" + FeatureName));
938 else
939 CmdArgs.push_back(Args.MakeArgString("-" + FeatureName));
940 }
941}
942
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000943void Clang::AddMIPSTargetArgs(const ArgList &Args,
944 ArgStringList &CmdArgs) const {
945 const Driver &D = getToolChain().getDriver();
946 StringRef CPUName;
947 StringRef ABIName;
948 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
949
950 CmdArgs.push_back("-target-cpu");
951 CmdArgs.push_back(CPUName.data());
952
953 CmdArgs.push_back("-target-abi");
954 CmdArgs.push_back(ABIName.data());
955
956 StringRef FloatABI = getMipsFloatABI(D, Args);
957
Eric Christopher0b26a612010-03-02 02:41:08 +0000958 if (FloatABI == "soft") {
959 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +0000960 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000961 CmdArgs.push_back("-mfloat-abi");
962 CmdArgs.push_back("soft");
963
964 // FIXME: Note, this is a hack. We need to pass the selected float
965 // mode to the MipsTargetInfoBase to define appropriate macros there.
966 // Now it is the only method.
967 CmdArgs.push_back("-target-feature");
968 CmdArgs.push_back("+soft-float");
969 }
970 else if (FloatABI == "single") {
971 // Restrict the use of hardware floating-point
972 // instructions to 32-bit operations.
973 CmdArgs.push_back("-target-feature");
974 CmdArgs.push_back("+single-float");
975 }
976 else {
977 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +0000978 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000979 CmdArgs.push_back("-mfloat-abi");
980 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +0000981 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +0000982
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000983 AddTargetFeature(Args, CmdArgs,
984 options::OPT_mips16, options::OPT_mno_mips16,
985 "mips16");
Simon Atanasyan9c6f1f72012-07-05 19:23:00 +0000986 AddTargetFeature(Args, CmdArgs,
987 options::OPT_mdsp, options::OPT_mno_dsp,
988 "dsp");
989 AddTargetFeature(Args, CmdArgs,
990 options::OPT_mdspr2, options::OPT_mno_dspr2,
991 "dspr2");
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000992
993 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000994 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +0000995 CmdArgs.push_back("-mllvm");
996 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
997 A->claim();
998 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000999}
1000
Hal Finkel8eb59282012-06-11 22:35:19 +00001001/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1002static std::string getPPCTargetCPU(const ArgList &Args) {
1003 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001004 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001005
1006 if (CPUName == "native") {
1007 std::string CPU = llvm::sys::getHostCPUName();
1008 if (!CPU.empty() && CPU != "generic")
1009 return CPU;
1010 else
1011 return "";
1012 }
1013
1014 return llvm::StringSwitch<const char *>(CPUName)
1015 .Case("common", "generic")
1016 .Case("440", "440")
1017 .Case("440fp", "440")
1018 .Case("450", "450")
1019 .Case("601", "601")
1020 .Case("602", "602")
1021 .Case("603", "603")
1022 .Case("603e", "603e")
1023 .Case("603ev", "603ev")
1024 .Case("604", "604")
1025 .Case("604e", "604e")
1026 .Case("620", "620")
1027 .Case("G3", "g3")
1028 .Case("7400", "7400")
1029 .Case("G4", "g4")
1030 .Case("7450", "7450")
1031 .Case("G4+", "g4+")
1032 .Case("750", "750")
1033 .Case("970", "970")
1034 .Case("G5", "g5")
1035 .Case("a2", "a2")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001036 .Case("e500mc", "e500mc")
1037 .Case("e5500", "e5500")
Hal Finkel8eb59282012-06-11 22:35:19 +00001038 .Case("power6", "pwr6")
1039 .Case("power7", "pwr7")
1040 .Case("powerpc", "ppc")
1041 .Case("powerpc64", "ppc64")
1042 .Default("");
1043 }
1044
1045 return "";
1046}
1047
1048void Clang::AddPPCTargetArgs(const ArgList &Args,
1049 ArgStringList &CmdArgs) const {
1050 std::string TargetCPUName = getPPCTargetCPU(Args);
1051
1052 // LLVM may default to generating code for the native CPU,
1053 // but, like gcc, we default to a more generic option for
1054 // each architecture. (except on Darwin)
1055 llvm::Triple Triple = getToolChain().getTriple();
1056 if (TargetCPUName.empty() && !Triple.isOSDarwin()) {
1057 if (Triple.getArch() == llvm::Triple::ppc64)
1058 TargetCPUName = "ppc64";
1059 else
1060 TargetCPUName = "ppc";
1061 }
1062
1063 if (!TargetCPUName.empty()) {
1064 CmdArgs.push_back("-target-cpu");
1065 CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str()));
1066 }
1067}
1068
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001069void Clang::AddSparcTargetArgs(const ArgList &Args,
1070 ArgStringList &CmdArgs) const {
1071 const Driver &D = getToolChain().getDriver();
1072
1073 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001074 CmdArgs.push_back("-target-cpu");
Richard Smithbd55daf2012-11-01 04:30:05 +00001075 CmdArgs.push_back(A->getValue());
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001076 }
1077
1078 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001079 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001080 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1081 options::OPT_mhard_float)) {
1082 if (A->getOption().matches(options::OPT_msoft_float))
1083 FloatABI = "soft";
1084 else if (A->getOption().matches(options::OPT_mhard_float))
1085 FloatABI = "hard";
1086 }
1087
1088 // If unspecified, choose the default based on the platform.
1089 if (FloatABI.empty()) {
1090 switch (getToolChain().getTriple().getOS()) {
1091 default:
1092 // Assume "soft", but warn the user we are guessing.
1093 FloatABI = "soft";
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001094 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001095 break;
1096 }
1097 }
1098
1099 if (FloatABI == "soft") {
1100 // Floating point operations and argument passing are soft.
1101 //
1102 // FIXME: This changes CPP defines, we need -target-soft-float.
1103 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001104 CmdArgs.push_back("-target-feature");
1105 CmdArgs.push_back("+soft-float");
1106 } else {
1107 assert(FloatABI == "hard" && "Invalid float abi!");
1108 CmdArgs.push_back("-mhard-float");
1109 }
1110}
1111
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001112void Clang::AddX86TargetArgs(const ArgList &Args,
1113 ArgStringList &CmdArgs) const {
Rafael Espindola7df35012012-11-02 20:41:30 +00001114 const bool isAndroid =
1115 getToolChain().getTriple().getEnvironment() == llvm::Triple::Android;
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001116 if (!Args.hasFlag(options::OPT_mred_zone,
1117 options::OPT_mno_red_zone,
1118 true) ||
1119 Args.hasArg(options::OPT_mkernel) ||
1120 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001121 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001122
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001123 if (Args.hasFlag(options::OPT_msoft_float,
1124 options::OPT_mno_soft_float,
1125 false))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001126 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001127
Daniel Dunbare13ada62009-11-14 22:04:54 +00001128 const char *CPUName = 0;
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001129 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001130 if (StringRef(A->getValue()) == "native") {
Daniel Dunbare13ada62009-11-14 22:04:54 +00001131 // FIXME: Reject attempts to use -march=native unless the target matches
1132 // the host.
1133 //
1134 // FIXME: We should also incorporate the detected target features for use
1135 // with -native.
1136 std::string CPU = llvm::sys::getHostCPUName();
Bob Wilsone78227b2012-05-09 17:53:10 +00001137 if (!CPU.empty() && CPU != "generic")
Daniel Dunbare13ada62009-11-14 22:04:54 +00001138 CPUName = Args.MakeArgString(CPU);
1139 } else
Richard Smithbd55daf2012-11-01 04:30:05 +00001140 CPUName = A->getValue();
Daniel Dunbare13ada62009-11-14 22:04:54 +00001141 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001142
Daniel Dunbare13ada62009-11-14 22:04:54 +00001143 // Select the default CPU if none was given (or detection failed).
1144 if (!CPUName) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001145 // FIXME: Need target hooks.
Bob Wilson6524dd32011-10-14 05:03:44 +00001146 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001147 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbare13ada62009-11-14 22:04:54 +00001148 CPUName = "core2";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001149 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbare13ada62009-11-14 22:04:54 +00001150 CPUName = "yonah";
Chris Lattnerb986aba2010-04-11 19:29:39 +00001151 } else if (getToolChain().getOS().startswith("haiku")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001152 if (getToolChain().getArch() == llvm::Triple::x86_64)
Chris Lattnerb986aba2010-04-11 19:29:39 +00001153 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001154 else if (getToolChain().getArch() == llvm::Triple::x86)
Chris Lattnerb986aba2010-04-11 19:29:39 +00001155 CPUName = "i586";
Daniel Dunbarea3813f2010-08-01 23:13:54 +00001156 } else if (getToolChain().getOS().startswith("openbsd")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001157 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbarea3813f2010-08-01 23:13:54 +00001158 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001159 else if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarea3813f2010-08-01 23:13:54 +00001160 CPUName = "i486";
Eli Friedman9fa28852012-08-08 23:57:20 +00001161 } else if (getToolChain().getOS().startswith("bitrig")) {
1162 if (getToolChain().getArch() == llvm::Triple::x86_64)
1163 CPUName = "x86-64";
1164 else if (getToolChain().getArch() == llvm::Triple::x86)
1165 CPUName = "i686";
Roman Divacky432f10d2011-03-01 18:11:37 +00001166 } else if (getToolChain().getOS().startswith("freebsd")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001167 if (getToolChain().getArch() == llvm::Triple::x86_64)
Roman Divacky432f10d2011-03-01 18:11:37 +00001168 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001169 else if (getToolChain().getArch() == llvm::Triple::x86)
Roman Divacky432f10d2011-03-01 18:11:37 +00001170 CPUName = "i486";
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001171 } else if (getToolChain().getOS().startswith("netbsd")) {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001172 if (getToolChain().getArch() == llvm::Triple::x86_64)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001173 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001174 else if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001175 CPUName = "i486";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001176 } else {
Daniel Dunbar116b3052011-05-31 15:58:55 +00001177 if (getToolChain().getArch() == llvm::Triple::x86_64)
Daniel Dunbare13ada62009-11-14 22:04:54 +00001178 CPUName = "x86-64";
Daniel Dunbar116b3052011-05-31 15:58:55 +00001179 else if (getToolChain().getArch() == llvm::Triple::x86)
Rafael Espindola7df35012012-11-02 20:41:30 +00001180 // All x86 devices running Android have core2 as their common
1181 // denominator. This makes a better choice than pentium4.
1182 CPUName = isAndroid ? "core2" : "pentium4";
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001183 }
1184 }
1185
Daniel Dunbare13ada62009-11-14 22:04:54 +00001186 if (CPUName) {
Daniel Dunbara7d02312009-12-18 06:30:12 +00001187 CmdArgs.push_back("-target-cpu");
Daniel Dunbare13ada62009-11-14 22:04:54 +00001188 CmdArgs.push_back(CPUName);
1189 }
1190
Eli Friedmanad811f02011-07-02 00:34:19 +00001191 // The required algorithm here is slightly strange: the options are applied
1192 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
1193 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
1194 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
1195 // former correctly, but not the latter; handle directly-overridden
1196 // attributes here.
1197 llvm::StringMap<unsigned> PrevFeature;
1198 std::vector<const char*> Features;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001199 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1200 ie = Args.filtered_end(); it != ie; ++it) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001201 StringRef Name = (*it)->getOption().getName();
Daniel Dunbara442fd52010-06-11 22:00:13 +00001202 (*it)->claim();
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001203
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001204 // Skip over "-m".
Michael J. Spencer929fccd2012-10-22 22:13:48 +00001205 assert(Name.startswith("m") && "Invalid feature name.");
1206 Name = Name.substr(1);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001207
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001208 bool IsNegative = Name.startswith("no-");
1209 if (IsNegative)
1210 Name = Name.substr(3);
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001211
Eli Friedmanad811f02011-07-02 00:34:19 +00001212 unsigned& Prev = PrevFeature[Name];
1213 if (Prev)
1214 Features[Prev - 1] = 0;
1215 Prev = Features.size() + 1;
1216 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1217 }
1218 for (unsigned i = 0; i < Features.size(); i++) {
1219 if (Features[i]) {
1220 CmdArgs.push_back("-target-feature");
1221 CmdArgs.push_back(Features[i]);
1222 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001223 }
1224}
1225
Tony Linthicum76329bf2011-12-12 21:14:55 +00001226static Arg* getLastHexagonArchArg (const ArgList &Args)
1227{
1228 Arg * A = NULL;
1229
Sebastian Pop86500282012-01-13 20:37:10 +00001230 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1231 it != ie; ++it) {
1232 if ((*it)->getOption().matches(options::OPT_march_EQ) ||
Tony Linthicum76329bf2011-12-12 21:14:55 +00001233 (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1234 A = *it;
1235 A->claim();
1236 }
Sebastian Pop86500282012-01-13 20:37:10 +00001237 else if ((*it)->getOption().matches(options::OPT_m_Joined)){
Richard Smithbd55daf2012-11-01 04:30:05 +00001238 StringRef Value = (*it)->getValue(0);
Sebastian Pop86500282012-01-13 20:37:10 +00001239 if (Value.startswith("v")) {
1240 A = *it;
1241 A->claim();
1242 }
1243 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001244 }
1245 return A;
1246}
1247
Sebastian Pop86500282012-01-13 20:37:10 +00001248static StringRef getHexagonTargetCPU(const ArgList &Args)
Tony Linthicum76329bf2011-12-12 21:14:55 +00001249{
1250 Arg *A;
1251 llvm::StringRef WhichHexagon;
1252
Sebastian Pop86500282012-01-13 20:37:10 +00001253 // Select the default CPU (v4) if none was given or detection failed.
Tony Linthicum76329bf2011-12-12 21:14:55 +00001254 if ((A = getLastHexagonArchArg (Args))) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001255 WhichHexagon = A->getValue();
Sebastian Pop86500282012-01-13 20:37:10 +00001256 if (WhichHexagon == "")
1257 return "v4";
1258 else
1259 return WhichHexagon;
Tony Linthicum76329bf2011-12-12 21:14:55 +00001260 }
Sebastian Pop86500282012-01-13 20:37:10 +00001261 else
1262 return "v4";
Tony Linthicum76329bf2011-12-12 21:14:55 +00001263}
1264
1265void Clang::AddHexagonTargetArgs(const ArgList &Args,
1266 ArgStringList &CmdArgs) const {
1267 llvm::Triple Triple = getToolChain().getTriple();
1268
1269 CmdArgs.push_back("-target-cpu");
Sebastian Pop86500282012-01-13 20:37:10 +00001270 CmdArgs.push_back(Args.MakeArgString("hexagon" + getHexagonTargetCPU(Args)));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001271 CmdArgs.push_back("-fno-signed-char");
1272 CmdArgs.push_back("-nobuiltininc");
1273
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001274 if (Args.hasArg(options::OPT_mqdsp6_compat))
Tony Linthicum76329bf2011-12-12 21:14:55 +00001275 CmdArgs.push_back("-mqdsp6-compat");
1276
1277 if (Arg *A = Args.getLastArg(options::OPT_G,
1278 options::OPT_msmall_data_threshold_EQ)) {
1279 std::string SmallDataThreshold="-small-data-threshold=";
Richard Smithbd55daf2012-11-01 04:30:05 +00001280 SmallDataThreshold += A->getValue();
Tony Linthicum76329bf2011-12-12 21:14:55 +00001281 CmdArgs.push_back ("-mllvm");
1282 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
1283 A->claim();
1284 }
1285
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001286 if (!Args.hasArg(options::OPT_fno_short_enums))
1287 CmdArgs.push_back("-fshort-enums");
1288 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1289 CmdArgs.push_back ("-mllvm");
1290 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1291 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001292 CmdArgs.push_back ("-mllvm");
1293 CmdArgs.push_back ("-machine-sink-split=0");
1294}
1295
Eric Christopher84fbdb42011-08-19 00:30:14 +00001296static bool
John McCall5fb5df92012-06-20 06:18:46 +00001297shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001298 const llvm::Triple &Triple) {
1299 // We use the zero-cost exception tables for Objective-C if the non-fragile
1300 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1301 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001302 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001303 return true;
1304
Bob Wilson6524dd32011-10-14 05:03:44 +00001305 if (!Triple.isOSDarwin())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001306 return false;
1307
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001308 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001309 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001310 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001311}
1312
Anders Carlssone96ab552011-02-28 02:27:16 +00001313/// addExceptionArgs - Adds exception related arguments to the driver command
1314/// arguments. There's a master flag, -fexceptions and also language specific
1315/// flags to enable/disable C++ and Objective-C exceptions.
1316/// This makes it possible to for example disable C++ exceptions but enable
1317/// Objective-C exceptions.
1318static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1319 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001320 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001321 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001322 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001323 if (KernelOrKext) {
1324 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1325 // arguments now to avoid warnings about unused arguments.
1326 Args.ClaimAllArgs(options::OPT_fexceptions);
1327 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1328 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1329 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1330 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1331 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001332 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001333 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001334
1335 // Exceptions are enabled by default.
1336 bool ExceptionsEnabled = true;
1337
1338 // This keeps track of whether exceptions were explicitly turned on or off.
1339 bool DidHaveExplicitExceptionFlag = false;
1340
Rafael Espindola00a66572009-10-01 13:33:33 +00001341 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1342 options::OPT_fno_exceptions)) {
1343 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001344 ExceptionsEnabled = true;
Eric Christopher84fbdb42011-08-19 00:30:14 +00001345 else
Anders Carlssone96ab552011-02-28 02:27:16 +00001346 ExceptionsEnabled = false;
1347
1348 DidHaveExplicitExceptionFlag = true;
Rafael Espindola00a66572009-10-01 13:33:33 +00001349 }
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001350
Anders Carlssone96ab552011-02-28 02:27:16 +00001351 bool ShouldUseExceptionTables = false;
Fariborz Jahaniane4b21ab2009-10-01 20:30:46 +00001352
Anders Carlssone96ab552011-02-28 02:27:16 +00001353 // Exception tables and cleanups can be enabled with -fexceptions even if the
1354 // language itself doesn't support exceptions.
1355 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1356 ShouldUseExceptionTables = true;
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001357
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001358 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1359 // is not necessarily sensible, but follows GCC.
1360 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001361 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001362 options::OPT_fno_objc_exceptions,
1363 true)) {
1364 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001365
Eric Christopher84fbdb42011-08-19 00:30:14 +00001366 ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001367 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001368 }
1369
1370 if (types::isCXX(InputType)) {
1371 bool CXXExceptionsEnabled = ExceptionsEnabled;
1372
Eric Christopher84fbdb42011-08-19 00:30:14 +00001373 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1374 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001375 options::OPT_fexceptions,
1376 options::OPT_fno_exceptions)) {
1377 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1378 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001379 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001380 CXXExceptionsEnabled = false;
1381 }
1382
1383 if (CXXExceptionsEnabled) {
1384 CmdArgs.push_back("-fcxx-exceptions");
1385
1386 ShouldUseExceptionTables = true;
1387 }
1388 }
1389
1390 if (ShouldUseExceptionTables)
1391 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001392}
1393
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001394static bool ShouldDisableCFI(const ArgList &Args,
1395 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001396 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001397 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001398 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001399 // we disable them if we think the .s file will be passed to it.
Rafael Espindolac41db922012-03-08 14:39:55 +00001400 Default = Args.hasFlag(options::OPT_integrated_as,
1401 options::OPT_no_integrated_as,
1402 TC.IsIntegratedAssemblerDefault());
Rafael Espindolaf934f982011-05-17 16:26:17 +00001403 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001404 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1405 options::OPT_fno_dwarf2_cfi_asm,
1406 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001407}
1408
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001409static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1410 const ToolChain &TC) {
1411 bool IsIADefault = TC.IsIntegratedAssemblerDefault();
1412 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1413 options::OPT_no_integrated_as,
1414 IsIADefault);
1415 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1416 options::OPT_fno_dwarf_directory_asm,
1417 UseIntegratedAs);
1418 return !UseDwarfDirectory;
1419}
1420
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001421/// \brief Check whether the given input tree contains any compilation actions.
1422static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001423 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001424 return true;
1425
1426 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1427 if (ContainsCompileAction(*it))
1428 return true;
1429
1430 return false;
1431}
1432
1433/// \brief Check if -relax-all should be passed to the internal assembler.
1434/// This is done by default when compiling non-assembler source with -O0.
1435static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1436 bool RelaxDefault = true;
1437
1438 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1439 RelaxDefault = A->getOption().matches(options::OPT_O0);
1440
1441 if (RelaxDefault) {
1442 RelaxDefault = false;
1443 for (ActionList::const_iterator it = C.getActions().begin(),
1444 ie = C.getActions().end(); it != ie; ++it) {
1445 if (ContainsCompileAction(*it)) {
1446 RelaxDefault = true;
1447 break;
1448 }
1449 }
1450 }
1451
1452 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1453 RelaxDefault);
1454}
1455
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001456SanitizerArgs::SanitizerArgs(const Driver &D, const ArgList &Args) {
1457 Kind = 0;
Richard Smith52be6192012-11-05 22:04:41 +00001458
1459 const Arg *AsanArg, *TsanArg, *UbsanArg;
Richard Smith52be6192012-11-05 22:04:41 +00001460 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
1461 unsigned Add = 0, Remove = 0;
Richard Smithaa716572012-11-06 01:12:02 +00001462 const char *DeprecatedReplacement = 0;
1463 if ((*I)->getOption().matches(options::OPT_faddress_sanitizer)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001464 Add = Address;
Richard Smithaa716572012-11-06 01:12:02 +00001465 DeprecatedReplacement = "-fsanitize=address";
1466 } else if ((*I)->getOption().matches(options::OPT_fno_address_sanitizer)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001467 Remove = Address;
Richard Smithaa716572012-11-06 01:12:02 +00001468 DeprecatedReplacement = "-fno-sanitize=address";
1469 } else if ((*I)->getOption().matches(options::OPT_fthread_sanitizer)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001470 Add = Thread;
Richard Smithaa716572012-11-06 01:12:02 +00001471 DeprecatedReplacement = "-fsanitize=thread";
1472 } else if ((*I)->getOption().matches(options::OPT_fno_thread_sanitizer)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001473 Remove = Thread;
Richard Smithaa716572012-11-06 01:12:02 +00001474 DeprecatedReplacement = "-fno-sanitize=thread";
1475 } else if ((*I)->getOption().matches(options::OPT_fcatch_undefined_behavior)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001476 Add = Undefined;
Richard Smithaa716572012-11-06 01:12:02 +00001477 DeprecatedReplacement = "-fsanitize=undefined";
1478 } else if ((*I)->getOption().matches(options::OPT_fsanitize_EQ)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001479 Add = parse(D, *I);
Richard Smithaa716572012-11-06 01:12:02 +00001480 } else if ((*I)->getOption().matches(options::OPT_fno_sanitize_EQ)) {
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001481 Remove = parse(D, *I);
Richard Smithaa716572012-11-06 01:12:02 +00001482 } else {
Richard Smith52be6192012-11-05 22:04:41 +00001483 continue;
Richard Smithaa716572012-11-06 01:12:02 +00001484 }
Richard Smith52be6192012-11-05 22:04:41 +00001485
1486 (*I)->claim();
1487
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001488 Kind |= Add;
1489 Kind &= ~Remove;
Richard Smith52be6192012-11-05 22:04:41 +00001490
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001491 if (Add & NeedsAsanRt) AsanArg = *I;
1492 if (Add & NeedsTsanRt) TsanArg = *I;
1493 if (Add & NeedsUbsanRt) UbsanArg = *I;
Richard Smithaa716572012-11-06 01:12:02 +00001494
1495 // If this is a deprecated synonym, produce a warning directing users
1496 // towards the new spelling.
1497 if (DeprecatedReplacement)
1498 D.Diag(diag::warn_drv_deprecated_arg)
1499 << (*I)->getAsString(Args) << DeprecatedReplacement;
Richard Smith52be6192012-11-05 22:04:41 +00001500 }
1501
1502 // Only one runtime library can be used at once.
1503 // FIXME: Allow Ubsan to be combined with the other two.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001504 bool NeedsAsan = needsAsanRt();
1505 bool NeedsTsan = needsTsanRt();
1506 bool NeedsUbsan = needsUbsanRt();
Richard Smith52be6192012-11-05 22:04:41 +00001507 if (NeedsAsan + NeedsTsan + NeedsUbsan > 1)
1508 D.Diag(diag::err_drv_argument_not_allowed_with)
Richard Smithaa716572012-11-06 01:12:02 +00001509 << describeSanitizeArg(Args, NeedsAsan ? AsanArg : TsanArg,
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001510 NeedsAsan ? NeedsAsanRt : NeedsTsanRt)
Richard Smithaa716572012-11-06 01:12:02 +00001511 << describeSanitizeArg(Args, NeedsUbsan ? UbsanArg : TsanArg,
Alexey Samsonov627b10f2012-11-06 15:09:03 +00001512 NeedsUbsan ? NeedsUbsanRt : NeedsTsanRt);
Richard Smith52be6192012-11-05 22:04:41 +00001513}
1514
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001515/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1516/// This needs to be called before we add the C run-time (malloc, etc).
1517static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00001518 ArgStringList &CmdArgs) {
Logan Chienc6fd8202012-09-02 09:30:11 +00001519 if(TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001520 if (!Args.hasArg(options::OPT_shared)) {
Evgeniy Stepanovea155f02012-06-04 11:15:05 +00001521 if (!Args.hasArg(options::OPT_pie))
1522 TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001523 }
Daniel Dunbar3ca41d42011-12-07 23:22:17 +00001524
Evgeniy Stepanovcac6aaa2012-09-12 09:09:08 +00001525 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1526 llvm::sys::path::append(LibAsan, "lib", "linux",
1527 (Twine("libclang_rt.asan-") +
1528 TC.getArchName() + "-android.so"));
1529 CmdArgs.push_back(Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001530 } else {
1531 if (!Args.hasArg(options::OPT_shared)) {
1532 // LibAsan is "libclang_rt.asan-<ArchName>.a" in the Linux library
1533 // resource directory.
1534 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1535 llvm::sys::path::append(LibAsan, "lib", "linux",
1536 (Twine("libclang_rt.asan-") +
1537 TC.getArchName() + ".a"));
1538 CmdArgs.push_back(Args.MakeArgString(LibAsan));
1539 CmdArgs.push_back("-lpthread");
1540 CmdArgs.push_back("-ldl");
1541 CmdArgs.push_back("-export-dynamic");
1542 }
1543 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001544}
1545
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001546/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1547/// This needs to be called before we add the C run-time (malloc, etc).
1548static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1549 ArgStringList &CmdArgs) {
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001550 if (!Args.hasArg(options::OPT_shared)) {
1551 // LibTsan is "libclang_rt.tsan-<ArchName>.a" in the Linux library
1552 // resource directory.
1553 SmallString<128> LibTsan(TC.getDriver().ResourceDir);
1554 llvm::sys::path::append(LibTsan, "lib", "linux",
1555 (Twine("libclang_rt.tsan-") +
1556 TC.getArchName() + ".a"));
1557 CmdArgs.push_back(Args.MakeArgString(LibTsan));
1558 CmdArgs.push_back("-lpthread");
1559 CmdArgs.push_back("-ldl");
1560 CmdArgs.push_back("-export-dynamic");
1561 }
1562}
1563
Richard Smithe30752c2012-10-09 19:52:38 +00001564/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1565/// (Linux).
1566static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1567 ArgStringList &CmdArgs) {
Richard Smithe30752c2012-10-09 19:52:38 +00001568 if (!Args.hasArg(options::OPT_shared)) {
1569 // LibUbsan is "libclang_rt.ubsan-<ArchName>.a" in the Linux library
1570 // resource directory.
1571 SmallString<128> LibUbsan(TC.getDriver().ResourceDir);
1572 llvm::sys::path::append(LibUbsan, "lib", "linux",
1573 (Twine("libclang_rt.ubsan-") +
1574 TC.getArchName() + ".a"));
1575 CmdArgs.push_back(Args.MakeArgString(LibUbsan));
Richard Smith437abed2012-11-02 20:32:19 +00001576 CmdArgs.push_back("-lpthread");
Richard Smithe30752c2012-10-09 19:52:38 +00001577 }
1578}
1579
Rafael Espindola224dd632011-12-14 21:02:23 +00001580static bool shouldUseFramePointer(const ArgList &Args,
1581 const llvm::Triple &Triple) {
1582 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1583 options::OPT_fomit_frame_pointer))
1584 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1585
Rafael Espindola00b29182011-12-14 21:50:24 +00001586 // Don't use a frame pointer on linux x86 and x86_64 if optimizing.
Rafael Espindola224dd632011-12-14 21:02:23 +00001587 if ((Triple.getArch() == llvm::Triple::x86_64 ||
1588 Triple.getArch() == llvm::Triple::x86) &&
1589 Triple.getOS() == llvm::Triple::Linux) {
1590 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1591 if (!A->getOption().matches(options::OPT_O0))
1592 return false;
1593 }
1594
1595 return true;
1596}
1597
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001598void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00001599 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00001600 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001601 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001602 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00001603 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1604 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00001605 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00001606 ArgStringList CmdArgs;
1607
Daniel Dunbare521a892009-03-31 20:53:55 +00001608 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1609
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00001610 // Invoke ourselves in -cc1 mode.
1611 //
1612 // FIXME: Implement custom jobs for internal actions.
1613 CmdArgs.push_back("-cc1");
1614
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001615 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00001616 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00001617 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001618 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00001619
Daniel Dunbar624c21b2009-10-30 18:12:20 +00001620 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00001621 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00001622
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001623 if (isa<AnalyzeJobAction>(JA)) {
1624 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1625 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00001626 } else if (isa<MigrateJobAction>(JA)) {
1627 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001628 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001629 if (Output.getType() == types::TY_Dependencies)
1630 CmdArgs.push_back("-Eonly");
1631 else
1632 CmdArgs.push_back("-E");
Daniel Dunbarc4343942010-02-03 03:07:56 +00001633 } else if (isa<AssembleJobAction>(JA)) {
1634 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001635
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001636 if (UseRelaxAll(C, Args))
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00001637 CmdArgs.push_back("-mrelax-all");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00001638
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001639 // When using an integrated assembler, translate -Wa, and -Xassembler
1640 // options.
1641 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1642 options::OPT_Xassembler),
1643 ie = Args.filtered_end(); it != ie; ++it) {
1644 const Arg *A = *it;
1645 A->claim();
1646
1647 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001648 StringRef Value = A->getValue(i);
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001649
1650 if (Value == "-force_cpusubtype_ALL") {
1651 // Do nothing, this is the default and we don't support anything else.
Daniel Dunbara78e5892010-10-28 20:36:23 +00001652 } else if (Value == "-L") {
Daniel Dunbar67919b22011-03-28 22:49:28 +00001653 CmdArgs.push_back("-msave-temp-labels");
Joerg Sonnenberger3028e462011-05-19 20:46:39 +00001654 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergerb487d2d2011-05-19 18:42:29 +00001655 CmdArgs.push_back("-mllvm");
1656 CmdArgs.push_back("-fatal-assembler-warnings");
Nick Lewyckyca6b90d2011-06-21 00:14:18 +00001657 } else if (Value == "--noexecstack") {
1658 CmdArgs.push_back("-mnoexecstack");
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001659 } else {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001660 D.Diag(diag::err_drv_unsupported_option_argument)
Daniel Dunbar2b4de142010-10-18 22:36:15 +00001661 << A->getOption().getName() << Value;
1662 }
1663 }
1664 }
Daniel Dunbar7c874332010-11-19 16:23:35 +00001665
1666 // Also ignore explicit -force_cpusubtype_ALL option.
1667 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001668 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00001669 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001670 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00001671
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001672 if (JA.getType() == types::TY_Nothing)
1673 CmdArgs.push_back("-fsyntax-only");
1674 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00001675 CmdArgs.push_back("-emit-pch");
1676 else
1677 CmdArgs.push_back("-emit-pth");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001678 } else {
1679 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001680
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001681 if (JA.getType() == types::TY_Nothing) {
1682 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001683 } else if (JA.getType() == types::TY_LLVM_IR ||
1684 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001685 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00001686 } else if (JA.getType() == types::TY_LLVM_BC ||
1687 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001688 CmdArgs.push_back("-emit-llvm-bc");
1689 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00001690 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001691 } else if (JA.getType() == types::TY_AST) {
1692 CmdArgs.push_back("-emit-pch");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001693 } else if (JA.getType() == types::TY_RewrittenObjC) {
1694 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001695 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00001696 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1697 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00001698 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001699 } else {
1700 assert(JA.getType() == types::TY_PP_Asm &&
1701 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001702 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00001703 }
1704
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001705 // The make clang go fast button.
1706 CmdArgs.push_back("-disable-free");
1707
John McCallbb79b5f2010-02-13 03:50:24 +00001708 // Disable the verification pass in -asserts builds.
1709#ifdef NDEBUG
1710 CmdArgs.push_back("-disable-llvm-verifier");
1711#endif
1712
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001713 // Set the main file name, so that debug info works even with
1714 // -save-temps.
1715 CmdArgs.push_back("-main-file-name");
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00001716 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00001717
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001718 // Some flags which affect the language (via preprocessor
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00001719 // defines). See darwin::CC1::AddCPPArgs.
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00001720 if (Args.hasArg(options::OPT_static))
1721 CmdArgs.push_back("-static-define");
1722
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001723 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00001724 // Enable region store model by default.
1725 CmdArgs.push_back("-analyzer-store=region");
1726
Ted Kremenek7bea9a12009-12-07 22:26:14 +00001727 // Treat blocks as analysis entry points.
1728 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1729
Ted Kremenek49c79792011-03-24 00:28:47 +00001730 CmdArgs.push_back("-analyzer-eagerly-assume");
1731
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001732 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001733 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001734 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00001735
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001736 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1737 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00001738
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00001739 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00001740 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00001741
1742 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00001743
1744 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00001745 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
1746 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
1747 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
1748 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
1749 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
1750 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001751 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001752
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001753 // Set the output format. The default is plist, for (lame) historical
1754 // reasons.
1755 CmdArgs.push_back("-analyzer-output");
1756 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00001757 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00001758 else
1759 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001760
Ted Kremenekfe449a22010-03-22 22:32:05 +00001761 // Disable the presentation of standard compiler warnings when
1762 // using --analyze. We only want to show static analyzer diagnostics
1763 // or frontend errors.
1764 CmdArgs.push_back("-w");
1765
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001766 // Add -Xanalyzer arguments when running as analyzer.
1767 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00001768 }
1769
Daniel Dunbar4eadb602009-09-10 01:21:12 +00001770 CheckCodeGenerationOptions(D, Args);
1771
Daniel Dunbar44e71222009-04-29 18:32:25 +00001772 // Perform argument translation for LLVM backend. This
1773 // takes some care in reconciling with llvm-gcc. The
1774 // issue is that llvm-gcc translates these options based on
1775 // the values in cc1, whereas we are processing based on
1776 // the driver arguments.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00001777
Daniel Dunbar44e71222009-04-29 18:32:25 +00001778 // This comes from the default translation the driver + cc1
1779 // would do to enable flag_pic.
Simon Atanasyana16b7fd2012-05-29 18:50:33 +00001780
1781 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
Benjamin Kramer76db2902012-11-13 15:32:35 +00001782 options::OPT_fpic, options::OPT_fno_pic);
1783 // We need to check for PIE flags separately because they can override the
1784 // PIC flags.
1785 Arg *LastPIEArg = Args.getLastArg(options::OPT_fPIE, options::OPT_fno_PIE,
Simon Atanasyana16b7fd2012-05-29 18:50:33 +00001786 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruthc0c04552012-04-08 16:40:35 +00001787 bool PICDisabled = false;
1788 bool PICEnabled = false;
1789 bool PICForPIE = false;
Benjamin Kramer76db2902012-11-13 15:32:35 +00001790 if (LastPIEArg) {
1791 PICForPIE = (LastPIEArg->getOption().matches(options::OPT_fPIE) ||
1792 LastPIEArg->getOption().matches(options::OPT_fpie));
1793 }
1794 if (LastPICArg || PICForPIE) {
1795 // The last PIE enabled argument can infer that PIC is enabled.
Chandler Carruthc0c04552012-04-08 16:40:35 +00001796 PICEnabled = (PICForPIE ||
1797 LastPICArg->getOption().matches(options::OPT_fPIC) ||
1798 LastPICArg->getOption().matches(options::OPT_fpic));
Benjamin Kramer76db2902012-11-13 15:32:35 +00001799 // We need to have PICDisabled inside the if statement because on darwin
1800 // PIC is enabled by default even if PIC arguments are not in the command
1801 // line (in this case causes PICDisabled to be true).
Chandler Carruthc0c04552012-04-08 16:40:35 +00001802 PICDisabled = !PICEnabled;
1803 }
1804 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
1805 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00001806 llvm::Triple Triple(TripleStr);
1807 if ((Args.hasArg(options::OPT_mkernel) ||
1808 Args.hasArg(options::OPT_fapple_kext)) &&
1809 (Triple.getOS() != llvm::Triple::IOS ||
1810 Triple.isOSVersionLT(6)))
Chandler Carruthc0c04552012-04-08 16:40:35 +00001811 PICDisabled = true;
1812 if (Args.hasArg(options::OPT_static))
1813 PICDisabled = true;
1814 bool DynamicNoPIC = Args.hasArg(options::OPT_mdynamic_no_pic);
1815
1816 // Select the relocation model.
Daniel Dunbar44e71222009-04-29 18:32:25 +00001817 const char *Model = getToolChain().GetForcedPicModel();
1818 if (!Model) {
Chandler Carruthc0c04552012-04-08 16:40:35 +00001819 if (DynamicNoPIC)
Daniel Dunbar44e71222009-04-29 18:32:25 +00001820 Model = "dynamic-no-pic";
1821 else if (PICDisabled)
1822 Model = "static";
1823 else if (PICEnabled)
1824 Model = "pic";
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001825 else
Daniel Dunbar44e71222009-04-29 18:32:25 +00001826 Model = getToolChain().GetDefaultRelocationModel();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00001827 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00001828 StringRef ModelStr = Model ? Model : "";
1829 if (Model && ModelStr != "pic") {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001830 CmdArgs.push_back("-mrelocation-model");
1831 CmdArgs.push_back(Model);
1832 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00001833
Chandler Carruthc0c04552012-04-08 16:40:35 +00001834 // Infer the __PIC__ and __PIE__ values.
1835 if (ModelStr == "pic" && PICForPIE) {
Benjamin Kramer76db2902012-11-13 15:32:35 +00001836 CmdArgs.push_back("-pic-level");
1837 CmdArgs.push_back((LastPIEArg &&
1838 LastPIEArg->getOption().matches(options::OPT_fPIE)) ?
1839 "2" : "1");
Chandler Carruthc0c04552012-04-08 16:40:35 +00001840 CmdArgs.push_back("-pie-level");
Benjamin Kramer76db2902012-11-13 15:32:35 +00001841 CmdArgs.push_back((LastPIEArg &&
1842 LastPIEArg->getOption().matches(options::OPT_fPIE)) ?
Chandler Carruthc0c04552012-04-08 16:40:35 +00001843 "2" : "1");
1844 } else if (ModelStr == "pic" || ModelStr == "dynamic-no-pic") {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00001845 CmdArgs.push_back("-pic-level");
Chandler Carruthc0c04552012-04-08 16:40:35 +00001846 CmdArgs.push_back(((ModelStr != "dynamic-no-pic" && LastPICArg &&
1847 LastPICArg->getOption().matches(options::OPT_fPIC)) ||
1848 getToolChain().getTriple().isOSDarwin()) ? "2" : "1");
Daniel Dunbar44e71222009-04-29 18:32:25 +00001849 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00001850
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00001851 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1852 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00001853 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00001854
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001855 // LLVM Code Generator Options.
1856
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001857 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1858 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00001859 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00001860 }
1861
Roman Divacky65b88cd2011-03-01 17:40:53 +00001862 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1863 CmdArgs.push_back("-mrtd");
1864
Rafael Espindola224dd632011-12-14 21:02:23 +00001865 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00001866 CmdArgs.push_back("-mdisable-fp-elim");
1867 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1868 options::OPT_fno_zero_initialized_in_bss))
1869 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Daniel Dunbar7aa71f92011-02-04 02:20:39 +00001870 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1871 options::OPT_fno_strict_aliasing,
1872 getToolChain().IsStrictAliasingDefault()))
Dan Gohman10169b92010-10-14 22:36:56 +00001873 CmdArgs.push_back("-relaxed-aliasing");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00001874 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
1875 false))
1876 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00001877 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
1878 options::OPT_fno_optimize_sibling_calls))
1879 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00001880
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001881 // Handle various floating point optimization flags, mapping them to the
1882 // appropriate LLVM code generation flags. The pattern for all of these is to
1883 // default off the codegen optimizations, and if any flag enables them and no
1884 // flag disables them after the flag enabling them, enable the codegen
1885 // optimization. This is complicated by several "umbrella" flags.
1886 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001887 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001888 options::OPT_ffinite_math_only,
1889 options::OPT_fno_finite_math_only,
1890 options::OPT_fhonor_infinities,
1891 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001892 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1893 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001894 A->getOption().getID() != options::OPT_fhonor_infinities)
1895 CmdArgs.push_back("-menable-no-infs");
1896 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001897 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001898 options::OPT_ffinite_math_only,
1899 options::OPT_fno_finite_math_only,
1900 options::OPT_fhonor_nans,
1901 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001902 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1903 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001904 A->getOption().getID() != options::OPT_fhonor_nans)
1905 CmdArgs.push_back("-menable-no-nans");
1906
Benjamin Kramerc242ef22012-05-02 14:55:48 +00001907 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
1908 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001909 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001910 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001911 options::OPT_fmath_errno,
Chandler Carruth3634c662012-04-26 02:10:51 +00001912 options::OPT_fno_math_errno))
1913 MathErrno = A->getOption().getID() == options::OPT_fmath_errno;
1914 if (MathErrno)
1915 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001916
1917 // There are several flags which require disabling very specific
1918 // optimizations. Any of these being disabled forces us to turn off the
1919 // entire set of LLVM optimizations, so collect them through all the flag
1920 // madness.
1921 bool AssociativeMath = false;
1922 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001923 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001924 options::OPT_funsafe_math_optimizations,
1925 options::OPT_fno_unsafe_math_optimizations,
1926 options::OPT_fassociative_math,
1927 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001928 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1929 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001930 A->getOption().getID() != options::OPT_fno_associative_math)
1931 AssociativeMath = true;
1932 bool ReciprocalMath = false;
1933 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001934 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001935 options::OPT_funsafe_math_optimizations,
1936 options::OPT_fno_unsafe_math_optimizations,
1937 options::OPT_freciprocal_math,
1938 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001939 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1940 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001941 A->getOption().getID() != options::OPT_fno_reciprocal_math)
1942 ReciprocalMath = true;
1943 bool SignedZeros = true;
1944 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001945 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001946 options::OPT_funsafe_math_optimizations,
1947 options::OPT_fno_unsafe_math_optimizations,
1948 options::OPT_fsigned_zeros,
1949 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001950 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1951 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001952 A->getOption().getID() != options::OPT_fsigned_zeros)
1953 SignedZeros = false;
1954 bool TrappingMath = true;
1955 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001956 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001957 options::OPT_funsafe_math_optimizations,
1958 options::OPT_fno_unsafe_math_optimizations,
1959 options::OPT_ftrapping_math,
1960 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001961 if (A->getOption().getID() != options::OPT_fno_fast_math &&
1962 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001963 A->getOption().getID() != options::OPT_ftrapping_math)
1964 TrappingMath = false;
1965 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
1966 !TrappingMath)
1967 CmdArgs.push_back("-menable-unsafe-fp-math");
1968
Lang Hamesaa53b932012-07-06 00:59:19 +00001969
1970 // Validate and pass through -fp-contract option.
1971 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001972 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00001973 options::OPT_ffp_contract)) {
1974 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001975 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00001976 if (Val == "fast" || Val == "on" || Val == "off") {
1977 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
1978 } else {
1979 D.Diag(diag::err_drv_unsupported_option_argument)
1980 << A->getOption().getName() << Val;
1981 }
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001982 } else if (A->getOption().getID() == options::OPT_ffast_math) {
Lang Hamesaa53b932012-07-06 00:59:19 +00001983 // If fast-math is set then set the fp-contract mode to fast.
1984 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
1985 }
1986 }
1987
Bob Wilson6a039162012-07-19 03:52:53 +00001988 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
1989 // and if we find them, tell the frontend to provide the appropriate
1990 // preprocessor macros. This is distinct from enabling any optimizations as
1991 // these options induce language changes which must survive serialization
1992 // and deserialization, etc.
Chad Rosierc30eb1c2012-09-25 22:03:25 +00001993 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math))
1994 if (A->getOption().matches(options::OPT_ffast_math))
1995 CmdArgs.push_back("-ffast-math");
1996 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
1997 if (A->getOption().matches(options::OPT_ffinite_math_only))
1998 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00001999
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002000 // Decide whether to use verbose asm. Verbose assembly is the default on
2001 // toolchains which have the integrated assembler on by default.
2002 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2003 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002004 IsVerboseAsmDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002005 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002006 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002007
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002008 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2009 CmdArgs.push_back("-mdebug-pass");
2010 CmdArgs.push_back("Structure");
2011 }
2012 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2013 CmdArgs.push_back("-mdebug-pass");
2014 CmdArgs.push_back("Arguments");
2015 }
2016
John McCall8517abc2010-02-19 02:45:38 +00002017 // Enable -mconstructor-aliases except on darwin, where we have to
2018 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002019 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002020 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002021
John McCall7ef5cb32011-03-18 02:56:14 +00002022 // Darwin's kernel doesn't support guard variables; just die if we
2023 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002024 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002025 CmdArgs.push_back("-fforbid-guard-variables");
2026
Douglas Gregordbe39272011-02-01 15:15:22 +00002027 if (Args.hasArg(options::OPT_mms_bitfields)) {
2028 CmdArgs.push_back("-mms-bitfields");
2029 }
John McCall8517abc2010-02-19 02:45:38 +00002030
Daniel Dunbar306945d2009-09-16 06:17:29 +00002031 // This is a coarse approximation of what llvm-gcc actually does, both
2032 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2033 // complicated ways.
2034 bool AsynchronousUnwindTables =
2035 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2036 options::OPT_fno_asynchronous_unwind_tables,
2037 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002038 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002039 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2040 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002041 CmdArgs.push_back("-munwind-tables");
2042
Rafael Espindola66aa0452012-06-19 01:26:10 +00002043 getToolChain().addClangTargetOptions(CmdArgs);
2044
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002045 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2046 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002047 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002048 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002049
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002050 // FIXME: Handle -mtune=.
2051 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002052
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002053 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002054 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002055 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002056 }
2057
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002058 // Add target specific cpu and features flags.
2059 switch(getToolChain().getTriple().getArch()) {
2060 default:
2061 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002062
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002063 case llvm::Triple::arm:
2064 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002065 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002066 break;
2067
Eric Christopher0b26a612010-03-02 02:41:08 +00002068 case llvm::Triple::mips:
2069 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002070 case llvm::Triple::mips64:
2071 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002072 AddMIPSTargetArgs(Args, CmdArgs);
2073 break;
2074
Hal Finkel8eb59282012-06-11 22:35:19 +00002075 case llvm::Triple::ppc:
2076 case llvm::Triple::ppc64:
2077 AddPPCTargetArgs(Args, CmdArgs);
2078 break;
2079
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002080 case llvm::Triple::sparc:
2081 AddSparcTargetArgs(Args, CmdArgs);
2082 break;
2083
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002084 case llvm::Triple::x86:
2085 case llvm::Triple::x86_64:
2086 AddX86TargetArgs(Args, CmdArgs);
2087 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002088
2089 case llvm::Triple::hexagon:
2090 AddHexagonTargetArgs(Args, CmdArgs);
2091 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002092 }
2093
Tony Linthicum76329bf2011-12-12 21:14:55 +00002094
2095
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002096 // Pass the linker version in use.
2097 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2098 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002099 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002100 }
2101
Nick Lewycky75033772011-02-02 06:43:03 +00002102 // -mno-omit-leaf-frame-pointer is the default on Darwin.
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002103 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
Nick Lewycky75033772011-02-02 06:43:03 +00002104 options::OPT_mno_omit_leaf_frame_pointer,
Bob Wilson6524dd32011-10-14 05:03:44 +00002105 !getToolChain().getTriple().isOSDarwin()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002106 CmdArgs.push_back("-momit-leaf-frame-pointer");
2107
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002108 // Explicitly error on some things we know we don't support and can't just
2109 // ignore.
2110 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002111 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2112 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002113 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002114 getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002115 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002116 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2117 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002118 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002119 << Unsupported->getOption().getName();
2120 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002121 }
2122
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002123 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002124 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002125 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002126 CmdArgs.push_back("-header-include-file");
2127 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2128 D.CCPrintHeadersFilename : "-");
2129 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002130 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002131 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002132
Chad Rosierbe10f982011-08-02 17:58:04 +00002133 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002134 CmdArgs.push_back("-diagnostic-log-file");
2135 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2136 D.CCLogDiagnosticsFilename : "-");
2137 }
2138
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002139 // Use the last option from "-g" group. "-gline-tables-only" is
2140 // preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002141 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002142 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2143 if (A->getOption().matches(options::OPT_gline_tables_only)) {
2144 CmdArgs.push_back("-gline-tables-only");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002145 } else if (!A->getOption().matches(options::OPT_g0) &&
2146 !A->getOption().matches(options::OPT_ggdb0)) {
Chad Rosier8fe3b112011-11-07 19:52:29 +00002147 CmdArgs.push_back("-g");
Chad Rosierc2bf3382011-11-04 19:28:44 +00002148 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002149 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002150
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002151 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2152 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002153 if (Args.hasArg(options::OPT_gcolumn_info))
2154 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002155
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002156 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2157 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2158
Chris Lattner3c77a352010-06-22 00:03:40 +00002159 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2160
Nick Lewycky207bce32011-04-21 23:44:07 +00002161 if (Args.hasArg(options::OPT_ftest_coverage) ||
2162 Args.hasArg(options::OPT_coverage))
2163 CmdArgs.push_back("-femit-coverage-notes");
2164 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2165 Args.hasArg(options::OPT_coverage))
2166 CmdArgs.push_back("-femit-coverage-data");
2167
Nick Lewycky480cb992011-05-04 20:46:58 +00002168 if (C.getArgs().hasArg(options::OPT_c) ||
2169 C.getArgs().hasArg(options::OPT_S)) {
2170 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002171 CmdArgs.push_back("-coverage-file");
Bill Wendling8c0b4bc2012-08-30 00:43:41 +00002172 SmallString<128> absFilename(Output.getFilename());
2173 llvm::sys::fs::make_absolute(absFilename);
2174 CmdArgs.push_back(Args.MakeArgString(absFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002175 }
2176 }
2177
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002178 // Pass options for controlling the default header search paths.
2179 if (Args.hasArg(options::OPT_nostdinc)) {
2180 CmdArgs.push_back("-nostdsysteminc");
2181 CmdArgs.push_back("-nobuiltininc");
2182 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002183 if (Args.hasArg(options::OPT_nostdlibinc))
2184 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002185 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2186 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2187 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002188
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002189 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002190 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002191 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002192
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002193 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2194
Ted Kremenekf7639e12012-03-06 20:06:33 +00002195 bool ARCMTEnabled = false;
John McCalld70fb982011-06-15 23:25:17 +00002196 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002197 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002198 options::OPT_ccc_arcmt_modify,
2199 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002200 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002201 switch (A->getOption().getID()) {
2202 default:
2203 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002204 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002205 CmdArgs.push_back("-arcmt-check");
2206 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002207 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002208 CmdArgs.push_back("-arcmt-modify");
2209 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002210 case options::OPT_ccc_arcmt_migrate:
2211 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002212 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002213 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002214
2215 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2216 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002217 break;
John McCalld70fb982011-06-15 23:25:17 +00002218 }
2219 }
2220 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002221
Ted Kremenekf7639e12012-03-06 20:06:33 +00002222 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2223 if (ARCMTEnabled) {
2224 D.Diag(diag::err_drv_argument_not_allowed_with)
2225 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2226 }
2227 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002228 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002229
2230 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2231 options::OPT_objcmt_migrate_subscripting)) {
2232 // None specified, means enable them all.
2233 CmdArgs.push_back("-objcmt-migrate-literals");
2234 CmdArgs.push_back("-objcmt-migrate-subscripting");
2235 } else {
2236 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2237 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2238 }
2239 }
2240
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002241 // Add preprocessing options like -I, -D, etc. if we are using the
2242 // preprocessor.
2243 //
2244 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002245 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Peter Collingbourne9b515cb2011-11-06 00:40:05 +00002246 AddPreprocessingOptions(C, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002247
Rafael Espindolaa7431922011-07-21 23:40:37 +00002248 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2249 // that "The compiler can only warn and ignore the option if not recognized".
2250 // When building with ccache, it will pass -D options to clang even on
2251 // preprocessed inputs and configure concludes that -fPIC is not supported.
2252 Args.ClaimAllArgs(options::OPT_D);
2253
Daniel Dunbar58f78332009-09-17 06:53:36 +00002254 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
Daniel Dunbar13864952009-03-24 20:17:30 +00002255 // others.
2256 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00002257 if (A->getOption().matches(options::OPT_O4))
Daniel Dunbar13864952009-03-24 20:17:30 +00002258 CmdArgs.push_back("-O3");
Daniel Dunbar9296f632010-05-27 06:51:08 +00002259 else if (A->getOption().matches(options::OPT_O) &&
Richard Smithbd55daf2012-11-01 04:30:05 +00002260 A->getValue()[0] == '\0')
Daniel Dunbar58f78332009-09-17 06:53:36 +00002261 CmdArgs.push_back("-O2");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002262 else
Daniel Dunbar7ef5ed62009-03-18 23:39:35 +00002263 A->render(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002264 }
2265
Daniel Dunbar945577c2009-10-29 02:24:45 +00002266 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002267 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2268 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002269 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002270 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002271
2272 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2273 // (-ansi is equivalent to -std=c89).
2274 //
2275 // If a std is supplied, only add -trigraphs if it follows the
2276 // option.
2277 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2278 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002279 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002280 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002281 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002282 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002283 else
2284 Std->render(Args, CmdArgs);
2285
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002286 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2287 options::OPT_trigraphs))
2288 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002289 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002290 } else {
2291 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002292 //
2293 // FIXME: Clang doesn't correctly handle -std= when the input language
2294 // doesn't match. For the time being just ignore this for C++ inputs;
2295 // eventually we want to do all the standard defaulting here instead of
2296 // splitting it between the driver and clang -cc1.
2297 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002298 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2299 "-std=", /*Joined=*/true);
2300 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2301 CmdArgs.push_back("-std=c++11");
2302
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002303 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002304 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002305
Chandler Carruthb009b142011-04-23 06:30:43 +00002306 // Map the bizarre '-Wwrite-strings' flag to a more sensible
2307 // '-fconst-strings'; this better indicates its actual behavior.
2308 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
2309 false)) {
2310 // For perfect compatibility with GCC, we do this even in the presence of
2311 // '-w'. This flag names something other than a warning for GCC.
2312 CmdArgs.push_back("-fconst-strings");
2313 }
2314
Chandler Carruth61fbf622011-04-23 09:27:53 +00002315 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002316 // during C++ compilation, which it is by default. GCC keeps this define even
2317 // in the presence of '-w', match this behavior bug-for-bug.
2318 if (types::isCXX(InputType) &&
2319 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2320 true)) {
2321 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002322 }
2323
Chandler Carruthe0391482010-05-22 02:21:53 +00002324 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2325 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2326 if (Asm->getOption().matches(options::OPT_fasm))
2327 CmdArgs.push_back("-fgnu-keywords");
2328 else
2329 CmdArgs.push_back("-fno-gnu-keywords");
2330 }
2331
Rafael Espindola4cfa7972011-05-02 17:43:32 +00002332 if (ShouldDisableCFI(Args, getToolChain()))
2333 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00002334
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002335 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2336 CmdArgs.push_back("-fno-dwarf-directory-asm");
2337
Nick Lewyckyba743b72011-10-21 02:32:14 +00002338 if (const char *pwd = ::getenv("PWD")) {
2339 // GCC also verifies that stat(pwd) and stat(".") have the same inode
2340 // number. Not doing those because stats are slow, but we could.
NAKAMURA Takumib5e6fa22011-10-22 10:25:25 +00002341 if (llvm::sys::path::is_absolute(pwd)) {
Nick Lewyckyba743b72011-10-21 02:32:14 +00002342 std::string CompDir = pwd;
2343 CmdArgs.push_back("-fdebug-compilation-dir");
2344 CmdArgs.push_back(Args.MakeArgString(CompDir));
2345 }
2346 }
2347
Richard Smith9a568822011-11-21 19:36:32 +00002348 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2349 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002350 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002351 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002352 }
2353
Richard Smith9a568822011-11-21 19:36:32 +00002354 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2355 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00002356 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00002357 }
2358
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00002359 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2360 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002361 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002362 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00002363 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2364 } else
2365 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00002366 }
2367
Nuno Lopes3d6311d2012-05-08 22:10:46 +00002368 if (Arg *A = Args.getLastArg(options::OPT_fbounds_checking,
2369 options::OPT_fbounds_checking_EQ)) {
2370 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002371 StringRef val = A->getValue();
Nuno Lopes3d6311d2012-05-08 22:10:46 +00002372 CmdArgs.push_back(Args.MakeArgString("-fbounds-checking=" + val));
2373 } else
2374 CmdArgs.push_back("-fbounds-checking=1");
2375 }
2376
Michael J. Spencer929fccd2012-10-22 22:13:48 +00002377 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002378 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00002379
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002380 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2381 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00002382 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002383 }
David Chisnall5778fce2009-08-31 16:41:57 +00002384
Chris Lattnere23003d2010-01-09 21:54:33 +00002385 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2386 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00002387 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00002388 }
2389
Chris Lattnerb35583d2010-04-07 20:49:23 +00002390 CmdArgs.push_back("-ferror-limit");
2391 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00002392 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00002393 else
2394 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00002395
Chandler Carrutha77a7272010-05-06 04:55:18 +00002396 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2397 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002398 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002399 }
2400
2401 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2402 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002403 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00002404 }
2405
Richard Smithf6f003a2011-12-16 19:06:07 +00002406 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2407 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00002408 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00002409 }
2410
Daniel Dunbar2c978472009-11-04 06:24:47 +00002411 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00002412 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00002413 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002414 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00002415 } else {
2416 // If -fmessage-length=N was not specified, determine whether this is a
2417 // terminal and, if so, implicitly define -fmessage-length appropriately.
2418 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002419 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00002420 }
2421
Daniel Dunbare357d562009-12-03 18:42:11 +00002422 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
2423 CmdArgs.push_back("-fvisibility");
Richard Smithbd55daf2012-11-01 04:30:05 +00002424 CmdArgs.push_back(A->getValue());
Daniel Dunbare357d562009-12-03 18:42:11 +00002425 }
2426
Douglas Gregor08329632010-06-15 17:05:35 +00002427 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002428
Hans Wennborgf60f6af2012-06-28 08:01:44 +00002429 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2430
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002431 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002432 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2433 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002434 CmdArgs.push_back("-ffreestanding");
2435
Daniel Dunbare357d562009-12-03 18:42:11 +00002436 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002437 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002438 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patel91bbb552010-09-30 19:05:55 +00002439 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Devang Patel384dfa42011-11-04 20:05:58 +00002440 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
Eric Christopher86050822011-10-25 07:13:06 +00002441 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Anton Yartsev9b6b2e52011-12-23 20:23:19 +00002442 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00002443 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2444 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00002445
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002446 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00002447 Sanitize.addArgs(Args, CmdArgs);
2448
Chad Rosier864dfe12012-03-13 23:45:51 +00002449 // Report and error for -faltivec on anything other then PowerPC.
2450 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
2451 if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc ||
2452 getToolChain().getTriple().getArch() == llvm::Triple::ppc64))
2453 D.Diag(diag::err_drv_argument_only_allowed_with)
2454 << A->getAsString(Args) << "ppc/ppc64";
2455
Daniel Dunbar733b0f82011-03-01 18:49:30 +00002456 if (getToolChain().SupportsProfiling())
2457 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00002458
2459 // -flax-vector-conversions is default.
2460 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2461 options::OPT_fno_lax_vector_conversions))
2462 CmdArgs.push_back("-fno-lax-vector-conversions");
2463
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002464 if (Args.getLastArg(options::OPT_fapple_kext))
2465 CmdArgs.push_back("-fapple-kext");
2466
David Blaikie690f21e2012-06-14 18:55:27 +00002467 if (Args.hasFlag(options::OPT_frewrite_includes,
2468 options::OPT_fno_rewrite_includes, false))
2469 CmdArgs.push_back("-frewrite-includes");
2470
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00002471 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00002472 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00002473 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002474 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2475 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00002476
2477 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2478 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00002479 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00002480 }
2481
Bob Wilson14adb362012-02-03 06:27:22 +00002482 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00002483
Chandler Carruth6e501032011-03-27 00:04:55 +00002484 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2485 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2486 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2487 options::OPT_fno_wrapv)) {
2488 if (A->getOption().matches(options::OPT_fwrapv))
2489 CmdArgs.push_back("-fwrapv");
2490 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2491 options::OPT_fno_strict_overflow)) {
2492 if (A->getOption().matches(options::OPT_fno_strict_overflow))
2493 CmdArgs.push_back("-fwrapv");
2494 }
Daniel Dunbar3a148f22009-04-07 21:51:40 +00002495 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Eric Christopherf387dbd2010-08-07 23:08:14 +00002496 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002497
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00002498 Args.AddLastArg(CmdArgs, options::OPT_pthread);
2499
Mahesha S6a682be42012-10-27 07:47:56 +00002500
Daniel Dunbar4930e332009-11-17 08:07:36 +00002501 // -stack-protector=0 is default.
2502 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002503 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2504 options::OPT_fstack_protector_all,
2505 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002506 if (A->getOption().matches(options::OPT_fstack_protector))
2507 StackProtectorLevel = 1;
2508 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2509 StackProtectorLevel = 2;
Nico Weberdd473632011-08-23 07:38:27 +00002510 } else {
2511 StackProtectorLevel =
2512 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2513 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002514 if (StackProtectorLevel) {
2515 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002516 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002517 }
Chad Rosierdb3da832012-08-21 16:16:06 +00002518
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002519 // --param ssp-buffer-size=
2520 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
2521 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002522 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002523 if (Str.startswith("ssp-buffer-size=")) {
2524 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00002525 CmdArgs.push_back("-stack-protector-buffer-size");
2526 // FIXME: Verify the argument is a valid integer.
2527 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00002528 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00002529 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00002530 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00002531 }
2532
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00002533 // Translate -mstackrealign
2534 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2535 false)) {
2536 CmdArgs.push_back("-backend-option");
2537 CmdArgs.push_back("-force-align-stack");
2538 }
2539 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2540 false)) {
2541 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2542 }
2543
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00002544 if (Args.hasArg(options::OPT_mstack_alignment)) {
2545 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2546 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00002547 }
Chad Rosier60027022012-11-09 17:29:19 +00002548 if (Args.hasArg(options::OPT_mstrict_align)) {
Chad Rosierd87e4f72012-11-09 18:27:01 +00002549 CmdArgs.push_back("-backend-option");
2550 CmdArgs.push_back("-arm-strict-align");
Chad Rosier60027022012-11-09 17:29:19 +00002551 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002552
Daniel Dunbard18049a2009-04-07 21:16:11 +00002553 // Forward -f options with positive and negative forms; we translate
2554 // these by hand.
2555
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002556 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00002557 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002558 CmdArgs.push_back("-fapple-kext");
2559 if (!Args.hasArg(options::OPT_fbuiltin))
2560 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00002561 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002562 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00002563 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002564 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00002565 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00002566
Nuno Lopes13c88c72009-12-16 16:59:22 +00002567 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2568 options::OPT_fno_assume_sane_operator_new))
2569 CmdArgs.push_back("-fno-assume-sane-operator-new");
2570
Daniel Dunbar4930e332009-11-17 08:07:36 +00002571 // -fblocks=0 is default.
2572 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00002573 getToolChain().IsBlocksDefault()) ||
2574 (Args.hasArg(options::OPT_fgnu_runtime) &&
2575 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
2576 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00002577 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00002578
2579 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
2580 !getToolChain().hasBlocksRuntime())
2581 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00002582 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00002583
Douglas Gregor226173a2012-01-18 15:19:58 +00002584 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
2585 // users must also pass -fcxx-modules. The latter flag will disappear once the
2586 // modules implementation is solid for C++/Objective-C++ programs as well.
2587 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
2588 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2589 options::OPT_fno_cxx_modules,
2590 false);
2591 if (AllowedInCXX || !types::isCXX(InputType))
2592 CmdArgs.push_back("-fmodules");
2593 }
Douglas Gregor787869b2012-01-03 17:13:05 +00002594
John McCalldfea9982010-04-09 19:12:06 +00002595 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00002596 if (Args.hasFlag(options::OPT_fno_access_control,
2597 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00002598 false))
John McCall3155f572010-04-09 19:03:51 +00002599 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00002600
Anders Carlssond470fef2010-11-21 00:09:52 +00002601 // -felide-constructors is the default.
2602 if (Args.hasFlag(options::OPT_fno_elide_constructors,
2603 options::OPT_felide_constructors,
2604 false))
2605 CmdArgs.push_back("-fno-elide-constructors");
2606
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002607 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002608 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00002609 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00002610 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00002611
Richard Smith52be6192012-11-05 22:04:41 +00002612 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00002613 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00002614 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00002615 Args.getLastArg(options::OPT_mkernel,
2616 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00002617 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00002618 D.Diag(diag::err_drv_argument_not_allowed_with)
2619 << "-fsanitize=vptr" << NoRttiArg;
2620 }
2621 }
2622
Tony Linthicum76329bf2011-12-12 21:14:55 +00002623 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002624 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00002625 options::OPT_fno_short_enums,
2626 getToolChain().getTriple().getArch() ==
2627 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00002628 CmdArgs.push_back("-fshort-enums");
2629
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002630 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002631 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00002632 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00002633 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00002634
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002635 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002636 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00002637 options::OPT_fno_threadsafe_statics))
2638 CmdArgs.push_back("-fno-threadsafe-statics");
2639
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002640 // -fuse-cxa-atexit is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00002641 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
2642 options::OPT_fno_use_cxa_atexit,
2643 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
Tony Linthicum76329bf2011-12-12 21:14:55 +00002644 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Chad Rosier4fab82c2012-03-26 22:04:46 +00002645 getToolChain().getTriple().getArch() != llvm::Triple::hexagon) ||
2646 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002647 CmdArgs.push_back("-fno-use-cxa-atexit");
2648
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002649 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00002650 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00002651 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2652 CmdArgs.push_back("-fms-extensions");
2653
Chad Rosiered943242012-07-20 21:20:33 +00002654 // -fms-inline-asm.
Chad Rosierd3957e52012-07-20 23:12:26 +00002655 if (Args.hasArg(options::OPT_fenable_experimental_ms_inline_asm))
2656 CmdArgs.push_back("-fenable-experimental-ms-inline-asm");
Chad Rosiered943242012-07-20 21:20:33 +00002657
Francois Pichet1b4f1632011-09-17 04:32:15 +00002658 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00002659 if (Args.hasFlag(options::OPT_fms_compatibility,
2660 options::OPT_fno_ms_compatibility,
2661 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
2662 Args.hasFlag(options::OPT_fms_extensions,
2663 options::OPT_fno_ms_extensions,
2664 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00002665 CmdArgs.push_back("-fms-compatibility");
2666
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002667 // -fmsc-version=1300 is default.
2668 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2669 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
2670 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002671 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002672 if (msc_ver.empty())
2673 CmdArgs.push_back("-fmsc-version=1300");
2674 else
2675 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
2676 }
2677
2678
Dawn Perchik68bb1b42010-09-02 23:59:25 +00002679 // -fborland-extensions=0 is default.
2680 if (Args.hasFlag(options::OPT_fborland_extensions,
2681 options::OPT_fno_borland_extensions, false))
2682 CmdArgs.push_back("-fborland-extensions");
2683
Francois Pichet02744872011-09-01 16:38:08 +00002684 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
2685 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00002686 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
2687 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00002688 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00002689 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00002690
Chandler Carruthe03aa552010-04-17 20:17:31 +00002691 // -fgnu-keywords default varies depending on language; only pass if
2692 // specified.
2693 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00002694 options::OPT_fno_gnu_keywords))
2695 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00002696
Rafael Espindola922a6242011-06-02 17:30:53 +00002697 if (Args.hasFlag(options::OPT_fgnu89_inline,
2698 options::OPT_fno_gnu89_inline,
2699 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00002700 CmdArgs.push_back("-fgnu89-inline");
2701
Chad Rosier9c76d242012-03-15 22:31:42 +00002702 if (Args.hasArg(options::OPT_fno_inline))
2703 CmdArgs.push_back("-fno-inline");
2704
Chad Rosier64d6be92012-03-06 21:17:19 +00002705 if (Args.hasArg(options::OPT_fno_inline_functions))
2706 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00002707
John McCall5fb5df92012-06-20 06:18:46 +00002708 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00002709
John McCall5fb5df92012-06-20 06:18:46 +00002710 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
2711 // legacy is the default.
2712 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00002713 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2714 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00002715 objcRuntime.isLegacyDispatchDefaultForArch(
2716 getToolChain().getTriple().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00002717 if (getToolChain().UseObjCMixedDispatch())
2718 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
2719 else
2720 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
2721 }
2722 }
2723
Nico Weber97bd94b2012-03-09 21:19:44 +00002724 // -fobjc-default-synthesize-properties=1 is default. This only has an effect
2725 // if the nonfragile objc abi is used.
Fariborz Jahanian05684072012-04-09 18:58:55 +00002726 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
David Chisnall3154e682011-09-30 13:32:35 +00002727 CmdArgs.push_back("-fobjc-default-synthesize-properties");
2728 }
2729
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00002730 // -fencode-extended-block-signature=1 is default.
2731 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
2732 CmdArgs.push_back("-fencode-extended-block-signature");
2733 }
2734
John McCall24fc0de2011-07-06 00:26:06 +00002735 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
2736 // NOTE: This logic is duplicated in ToolChains.cpp.
2737 bool ARC = isObjCAutoRefCount(Args);
2738 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00002739 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00002740
John McCall24fc0de2011-07-06 00:26:06 +00002741 CmdArgs.push_back("-fobjc-arc");
2742
Chandler Carruth491db322011-11-04 07:34:47 +00002743 // FIXME: It seems like this entire block, and several around it should be
2744 // wrapped in isObjC, but for now we just use it here as this is where it
2745 // was being used previously.
2746 if (types::isCXX(InputType) && types::isObjC(InputType)) {
2747 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2748 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
2749 else
2750 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
2751 }
2752
John McCall24fc0de2011-07-06 00:26:06 +00002753 // Allow the user to enable full exceptions code emission.
2754 // We define off for Objective-CC, on for Objective-C++.
2755 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2756 options::OPT_fno_objc_arc_exceptions,
2757 /*default*/ types::isCXX(InputType)))
2758 CmdArgs.push_back("-fobjc-arc-exceptions");
2759 }
2760
2761 // -fobjc-infer-related-result-type is the default, except in the Objective-C
2762 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00002763 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00002764 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002765
John McCall24fc0de2011-07-06 00:26:06 +00002766 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
2767 // takes precedence.
2768 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
2769 if (!GCArg)
2770 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
2771 if (GCArg) {
2772 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002773 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00002774 << GCArg->getAsString(Args);
2775 } else if (getToolChain().SupportsObjCGC()) {
2776 GCArg->render(Args, CmdArgs);
2777 } else {
2778 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002779 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00002780 << GCArg->getAsString(Args);
2781 }
2782 }
2783
John McCallb5f652e2011-06-22 00:53:57 +00002784 // Add exception args.
2785 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00002786 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00002787
2788 if (getToolChain().UseSjLjExceptions())
2789 CmdArgs.push_back("-fsjlj-exceptions");
2790
2791 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00002792 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2793 options::OPT_fno_assume_sane_operator_new))
2794 CmdArgs.push_back("-fno-assume-sane-operator-new");
2795
Daniel Dunbar34d7a992010-04-27 15:34:57 +00002796 // -fconstant-cfstrings is default, and may be subject to argument translation
2797 // on Darwin.
2798 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2799 options::OPT_fno_constant_cfstrings) ||
2800 !Args.hasFlag(options::OPT_mconstant_cfstrings,
2801 options::OPT_mno_constant_cfstrings))
2802 CmdArgs.push_back("-fno-constant-cfstrings");
2803
John Thompsoned4e2952009-11-05 20:14:16 +00002804 // -fshort-wchar default varies depending on platform; only
2805 // pass if specified.
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00002806 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2807 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00002808
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +00002809 // -fno-pascal-strings is default, only pass non-default. If the tool chain
2810 // happened to translate to -mpascal-strings, we want to back translate here.
Daniel Dunbard4510f22009-04-07 23:51:44 +00002811 //
2812 // FIXME: This is gross; that translation should be pulled from the
2813 // tool chain.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002814 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00002815 options::OPT_fno_pascal_strings,
2816 false) ||
2817 Args.hasFlag(options::OPT_mpascal_strings,
2818 options::OPT_mno_pascal_strings,
2819 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002820 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002821
Daniel Dunbar096ed292011-10-05 21:04:55 +00002822 // Honor -fpack-struct= and -fpack-struct, if given. Note that
2823 // -fno-pack-struct doesn't apply to -fpack-struct=.
2824 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00002825 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00002826 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00002827 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00002828 } else if (Args.hasFlag(options::OPT_fpack_struct,
2829 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00002830 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00002831 }
2832
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002833 if (Args.hasArg(options::OPT_mkernel) ||
2834 Args.hasArg(options::OPT_fapple_kext)) {
2835 if (!Args.hasArg(options::OPT_fcommon))
2836 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00002837 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002838 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00002839
Daniel Dunbard18049a2009-04-07 21:16:11 +00002840 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00002841 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00002842 CmdArgs.push_back("-fno-common");
2843
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002844 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00002845 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00002846 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002847 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002848 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00002849 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2850
Daniel Dunbar6358d682010-10-15 22:30:42 +00002851 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2852 if (!Args.hasFlag(options::OPT_ffor_scope,
2853 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002854 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00002855 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2856
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00002857 // -fcaret-diagnostics is default.
2858 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2859 options::OPT_fno_caret_diagnostics, true))
2860 CmdArgs.push_back("-fno-caret-diagnostics");
2861
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002862 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00002863 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00002864 options::OPT_fno_diagnostics_fixit_info))
2865 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002866
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002867 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00002868 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002869 options::OPT_fno_diagnostics_show_option))
2870 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002871
Chris Lattnerbf6fac82010-05-04 21:55:25 +00002872 if (const Arg *A =
2873 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2874 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00002875 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00002876 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00002877
Douglas Gregor643c9222011-05-21 17:07:29 +00002878 if (const Arg *A =
2879 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2880 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00002881 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00002882 }
2883
Chandler Carruthb6766f02011-03-27 01:50:55 +00002884 if (Arg *A = Args.getLastArg(
2885 options::OPT_fdiagnostics_show_note_include_stack,
2886 options::OPT_fno_diagnostics_show_note_include_stack)) {
2887 if (A->getOption().matches(
2888 options::OPT_fdiagnostics_show_note_include_stack))
2889 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2890 else
2891 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2892 }
2893
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002894 // Color diagnostics are the default, unless the terminal doesn't support
2895 // them.
2896 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
Argyrios Kyrtzidis4f920162010-09-23 12:56:06 +00002897 options::OPT_fno_color_diagnostics,
2898 llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00002899 CmdArgs.push_back("-fcolor-diagnostics");
2900
Daniel Dunbardb097022009-06-08 21:13:54 +00002901 if (!Args.hasFlag(options::OPT_fshow_source_location,
2902 options::OPT_fno_show_source_location))
2903 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00002904
Douglas Gregor643c9222011-05-21 17:07:29 +00002905 if (!Args.hasFlag(options::OPT_fshow_column,
2906 options::OPT_fno_show_column,
2907 true))
2908 CmdArgs.push_back("-fno-show-column");
2909
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00002910 if (!Args.hasFlag(options::OPT_fspell_checking,
2911 options::OPT_fno_spell_checking))
2912 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00002913
Daniel Dunbar473f8a62010-10-18 22:49:46 +00002914
Daniel Dunbar3ada2b72010-11-02 19:42:04 +00002915 // Silently ignore -fasm-blocks for now.
2916 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2917 false);
Daniel Dunbar473f8a62010-10-18 22:49:46 +00002918
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00002919 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2920 A->render(Args, CmdArgs);
2921
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002922 // -fdollars-in-identifiers default varies depending on platform and
2923 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00002924 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002925 options::OPT_fno_dollars_in_identifiers)) {
2926 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00002927 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002928 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00002929 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00002930 }
2931
Daniel Dunbaradeeb052009-05-22 19:02:20 +00002932 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
2933 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00002934 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00002935 options::OPT_fno_unit_at_a_time)) {
2936 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002937 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00002938 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00002939
Eli Friedman055c9702011-11-02 01:53:16 +00002940 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
2941 options::OPT_fno_apple_pragma_pack, false))
2942 CmdArgs.push_back("-fapple-pragma-pack");
2943
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00002944 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00002945 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002946 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00002947#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00002948 if (getToolChain().getTriple().isOSDarwin() &&
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00002949 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2950 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
2951 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2952 CmdArgs.push_back("-fno-builtin-strcat");
2953 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2954 CmdArgs.push_back("-fno-builtin-strcpy");
2955 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00002956#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00002957
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00002958 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00002959 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00002960 options::OPT_traditional_cpp)) {
2961 if (isa<PreprocessJobAction>(JA))
2962 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00002963 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002964 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00002965 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00002966
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002967 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00002968 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00002969
2970 // Handle serialized diagnostics.
2971 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
2972 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00002973 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00002974 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002975
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00002976 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
2977 CmdArgs.push_back("-fretain-comments-from-system-headers");
2978
Daniel Dunbar76fa8402010-04-15 06:09:03 +00002979 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
2980 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002981 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00002982 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
2983 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00002984 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00002985
Daniel Dunbar76fa8402010-04-15 06:09:03 +00002986 // We translate this by hand to the -cc1 argument, since nightly test uses
2987 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00002988 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00002989 CmdArgs.push_back("-disable-llvm-optzns");
2990 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00002991 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00002992 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002993
Daniel Dunbard67a3222009-03-30 06:36:42 +00002994 if (Output.getType() == types::TY_Dependencies) {
2995 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00002996 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00002997 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00002998 CmdArgs.push_back(Output.getFilename());
2999 } else {
3000 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003001 }
3002
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003003 for (InputInfoList::const_iterator
3004 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3005 const InputInfo &II = *it;
3006 CmdArgs.push_back("-x");
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00003007 if (Args.hasArg(options::OPT_rewrite_objc))
3008 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3009 else
3010 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbarb440f562010-08-02 02:38:21 +00003011 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003012 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003013 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003014 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003015 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003016
Chris Lattnere9d7d782009-11-03 19:50:27 +00003017 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3018
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003019 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003020
3021 // Optionally embed the -cc1 level arguments into the debug info, for build
3022 // analysis.
3023 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003024 ArgStringList OriginalArgs;
3025 for (ArgList::const_iterator it = Args.begin(),
3026 ie = Args.end(); it != ie; ++it)
3027 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003028
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003029 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003030 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003031 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003032 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003033 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003034 }
3035 CmdArgs.push_back("-dwarf-debug-flags");
3036 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3037 }
3038
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003039 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar17731772009-03-23 19:03:36 +00003040
Roman Divacky178e01602011-02-10 16:52:03 +00003041 if (Arg *A = Args.getLastArg(options::OPT_pg))
3042 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003043 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003044 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003045
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003046 // Claim some arguments which clang supports automatically.
3047
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003048 // -fpch-preprocess is used with gcc to add a special marker in the output to
3049 // include the PCH file. Clang's PTH solution is completely transparent, so we
3050 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003051 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003052
Daniel Dunbar17731772009-03-23 19:03:36 +00003053 // Claim some arguments which clang doesn't support, but we don't
3054 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003055 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3056 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003057
Rafael Espindolad95a8122011-03-01 05:25:27 +00003058 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
Rafael Espindola22f603032011-02-28 23:29:45 +00003059 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003060 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003061}
3062
Jim Grosbach576452b2012-02-10 20:37:10 +00003063void ClangAs::AddARMTargetArgs(const ArgList &Args,
3064 ArgStringList &CmdArgs) const {
3065 const Driver &D = getToolChain().getDriver();
3066 llvm::Triple Triple = getToolChain().getTriple();
3067
3068 // Set the CPU based on -march= and -mcpu=.
3069 CmdArgs.push_back("-target-cpu");
Benjamin Kramer09811c72012-06-26 22:20:06 +00003070 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
Jim Grosbach576452b2012-02-10 20:37:10 +00003071
3072 // Honor -mfpu=.
Chad Rosiercfbfc582012-04-04 20:51:35 +00003073 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Chad Rosierd1717c12012-04-04 20:56:36 +00003074 addFPUArgs(D, A, Args, CmdArgs);
Chad Rosier1f0e52e2012-04-04 20:39:32 +00003075
3076 // Honor -mfpmath=.
3077 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
Chad Rosier45619cb2012-04-04 22:13:40 +00003078 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
Jim Grosbach576452b2012-02-10 20:37:10 +00003079}
3080
John McCall5fb5df92012-06-20 06:18:46 +00003081/// Add options related to the Objective-C runtime/ABI.
3082///
3083/// Returns true if the runtime is non-fragile.
3084ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3085 ArgStringList &cmdArgs,
3086 RewriteKind rewriteKind) const {
3087 // Look for the controlling runtime option.
3088 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3089 options::OPT_fgnu_runtime,
3090 options::OPT_fobjc_runtime_EQ);
3091
3092 // Just forward -fobjc-runtime= to the frontend. This supercedes
3093 // options about fragility.
3094 if (runtimeArg &&
3095 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3096 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003097 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003098 if (runtime.tryParse(value)) {
3099 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3100 << value;
3101 }
3102
3103 runtimeArg->render(args, cmdArgs);
3104 return runtime;
3105 }
3106
3107 // Otherwise, we'll need the ABI "version". Version numbers are
3108 // slightly confusing for historical reasons:
3109 // 1 - Traditional "fragile" ABI
3110 // 2 - Non-fragile ABI, version 1
3111 // 3 - Non-fragile ABI, version 2
3112 unsigned objcABIVersion = 1;
3113 // If -fobjc-abi-version= is present, use that to set the version.
3114 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003115 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003116 if (value == "1")
3117 objcABIVersion = 1;
3118 else if (value == "2")
3119 objcABIVersion = 2;
3120 else if (value == "3")
3121 objcABIVersion = 3;
3122 else
3123 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3124 << value;
3125 } else {
3126 // Otherwise, determine if we are using the non-fragile ABI.
3127 bool nonFragileABIIsDefault =
3128 (rewriteKind == RK_NonFragile ||
3129 (rewriteKind == RK_None &&
3130 getToolChain().IsObjCNonFragileABIDefault()));
3131 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3132 options::OPT_fno_objc_nonfragile_abi,
3133 nonFragileABIIsDefault)) {
3134 // Determine the non-fragile ABI version to use.
3135#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3136 unsigned nonFragileABIVersion = 1;
3137#else
3138 unsigned nonFragileABIVersion = 2;
3139#endif
3140
3141 if (Arg *abiArg = args.getLastArg(
3142 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003143 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003144 if (value == "1")
3145 nonFragileABIVersion = 1;
3146 else if (value == "2")
3147 nonFragileABIVersion = 2;
3148 else
3149 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3150 << value;
3151 }
3152
3153 objcABIVersion = 1 + nonFragileABIVersion;
3154 } else {
3155 objcABIVersion = 1;
3156 }
3157 }
3158
3159 // We don't actually care about the ABI version other than whether
3160 // it's non-fragile.
3161 bool isNonFragile = objcABIVersion != 1;
3162
3163 // If we have no runtime argument, ask the toolchain for its default runtime.
3164 // However, the rewriter only really supports the Mac runtime, so assume that.
3165 ObjCRuntime runtime;
3166 if (!runtimeArg) {
3167 switch (rewriteKind) {
3168 case RK_None:
3169 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3170 break;
3171 case RK_Fragile:
3172 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3173 break;
3174 case RK_NonFragile:
3175 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3176 break;
3177 }
3178
3179 // -fnext-runtime
3180 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3181 // On Darwin, make this use the default behavior for the toolchain.
3182 if (getToolChain().getTriple().isOSDarwin()) {
3183 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3184
3185 // Otherwise, build for a generic macosx port.
3186 } else {
3187 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3188 }
3189
3190 // -fgnu-runtime
3191 } else {
3192 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00003193 // Legacy behaviour is to target the gnustep runtime if we are i
3194 // non-fragile mode or the GCC runtime in fragile mode.
3195 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00003196 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00003197 else
3198 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00003199 }
3200
3201 cmdArgs.push_back(args.MakeArgString(
3202 "-fobjc-runtime=" + runtime.getAsString()));
3203 return runtime;
3204}
3205
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003206void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003207 const InputInfo &Output,
3208 const InputInfoList &Inputs,
3209 const ArgList &Args,
3210 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003211 ArgStringList CmdArgs;
3212
3213 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3214 const InputInfo &Input = Inputs[0];
3215
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003216 // Don't warn about "clang -w -c foo.s"
3217 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00003218 // and "clang -emit-llvm -c foo.s"
3219 Args.ClaimAllArgs(options::OPT_emit_llvm);
3220 // and "clang -use-gold-plugin -c foo.s"
3221 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00003222
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003223 // Invoke ourselves in -cc1as mode.
3224 //
3225 // FIXME: Implement custom jobs for internal actions.
3226 CmdArgs.push_back("-cc1as");
3227
3228 // Add the "effective" target triple.
3229 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00003230 std::string TripleStr =
3231 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003232 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3233
3234 // Set the output mode, we currently only expect to be used as a real
3235 // assembler.
3236 CmdArgs.push_back("-filetype");
3237 CmdArgs.push_back("obj");
3238
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00003239 if (UseRelaxAll(C, Args))
Daniel Dunbar99ca8b72010-05-28 16:43:21 +00003240 CmdArgs.push_back("-relax-all");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003241
Jim Grosbach576452b2012-02-10 20:37:10 +00003242 // Add target specific cpu and features flags.
3243 switch(getToolChain().getTriple().getArch()) {
3244 default:
3245 break;
3246
3247 case llvm::Triple::arm:
3248 case llvm::Triple::thumb:
3249 AddARMTargetArgs(Args, CmdArgs);
3250 break;
3251 }
3252
Daniel Dunbar1d733e22011-03-17 17:37:29 +00003253 // Ignore explicit -force_cpusubtype_ALL option.
3254 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003255
Eric Christopherfc3ee562012-01-10 00:38:01 +00003256 // Determine the original source input.
3257 const Action *SourceAction = &JA;
3258 while (SourceAction->getKind() != Action::InputClass) {
3259 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3260 SourceAction = SourceAction->getInputs()[0];
3261 }
3262
3263 // Forward -g, assuming we are dealing with an actual assembly file.
3264 if (SourceAction->getType() == types::TY_Asm ||
3265 SourceAction->getType() == types::TY_PP_Asm) {
3266 Args.ClaimAllArgs(options::OPT_g_Group);
3267 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3268 if (!A->getOption().matches(options::OPT_g0))
3269 CmdArgs.push_back("-g");
3270 }
Kevin Enderby292dc082011-12-22 19:31:58 +00003271
3272 // Optionally embed the -cc1as level arguments into the debug info, for build
3273 // analysis.
3274 if (getToolChain().UseDwarfDebugFlags()) {
3275 ArgStringList OriginalArgs;
3276 for (ArgList::const_iterator it = Args.begin(),
3277 ie = Args.end(); it != ie; ++it)
3278 (*it)->render(Args, OriginalArgs);
3279
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003280 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00003281 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3282 Flags += Exec;
3283 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3284 Flags += " ";
3285 Flags += OriginalArgs[i];
3286 }
3287 CmdArgs.push_back("-dwarf-debug-flags");
3288 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3289 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003290
3291 // FIXME: Add -static support, once we have it.
3292
3293 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3294 options::OPT_Xassembler);
Daniel Dunbar252e8f92011-04-29 17:53:18 +00003295 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003296
3297 assert(Output.isFilename() && "Unexpected lipo output.");
3298 CmdArgs.push_back("-o");
3299 CmdArgs.push_back(Output.getFilename());
3300
Daniel Dunbarb440f562010-08-02 02:38:21 +00003301 assert(Input.isFilename() && "Invalid input.");
3302 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003303
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003304 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003305 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00003306}
3307
Daniel Dunbara3246a02009-03-18 08:07:30 +00003308void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003309 const InputInfo &Output,
3310 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003311 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00003312 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00003313 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003314 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003315
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003316 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003317 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003318 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00003319 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00003320 // Don't forward any -g arguments to assembly steps.
3321 if (isa<AssembleJobAction>(JA) &&
3322 A->getOption().matches(options::OPT_g_Group))
3323 continue;
3324
Daniel Dunbar2da02722009-03-19 07:55:12 +00003325 // It is unfortunate that we have to claim here, as this means
3326 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00003327 // platforms using a generic gcc, even if we are just using gcc
3328 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00003329 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003330 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00003331 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003332 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003333
Daniel Dunbar4e295052010-01-25 22:35:08 +00003334 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003335
3336 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003337 llvm::Triple::ArchType Arch = getToolChain().getArch();
Bob Wilson6524dd32011-10-14 05:03:44 +00003338 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003339 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00003340
3341 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003342 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003343 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003344 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003345 CmdArgs.push_back("ppc64");
3346 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003347 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00003348 }
3349
Daniel Dunbar5716d872009-05-02 21:41:52 +00003350 // Try to force gcc to match the tool chain we want, if we recognize
3351 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00003352 //
3353 // FIXME: The triple class should directly provide the information we want
3354 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003355 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003356 CmdArgs.push_back("-m32");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00003357 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86_64)
Daniel Dunbar5716d872009-05-02 21:41:52 +00003358 CmdArgs.push_back("-m64");
3359
Daniel Dunbarb440f562010-08-02 02:38:21 +00003360 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003361 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003362 CmdArgs.push_back(Output.getFilename());
3363 } else {
3364 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003365 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003366 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003367
Tony Linthicum76329bf2011-12-12 21:14:55 +00003368 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3369 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003370
3371 // Only pass -x if gcc will understand it; otherwise hope gcc
3372 // understands the suffix correctly. The main use case this would go
3373 // wrong in is for linker inputs if they happened to have an odd
3374 // suffix; really the only way to get this to happen is a command
3375 // like '-x foobar a.c' which will treat a.c like a linker input.
3376 //
3377 // FIXME: For the linker case specifically, can we safely convert
3378 // inputs into '-Wl,' options?
3379 for (InputInfoList::const_iterator
3380 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3381 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003382
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003383 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003384 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3385 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003386 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003387 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003388 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003389 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003390 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00003391
Daniel Dunbara3246a02009-03-18 08:07:30 +00003392 if (types::canTypeBeUserSpecified(II.getType())) {
3393 CmdArgs.push_back("-x");
3394 CmdArgs.push_back(types::getTypeName(II.getType()));
3395 }
3396
Daniel Dunbarb440f562010-08-02 02:38:21 +00003397 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003398 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00003399 else {
3400 const Arg &A = II.getInputArg();
3401
3402 // Reverse translate some rewritten options.
3403 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
3404 CmdArgs.push_back("-lstdc++");
3405 continue;
3406 }
3407
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003408 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00003409 A.render(Args, CmdArgs);
3410 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00003411 }
3412
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003413 const std::string customGCCName = D.getCCCGenericGCCName();
3414 const char *GCCName;
3415 if (!customGCCName.empty())
3416 GCCName = customGCCName.c_str();
3417 else if (D.CCCIsCXX) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003418 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00003419 } else
3420 GCCName = "gcc";
3421
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003422 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00003423 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00003424 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003425}
3426
Daniel Dunbar4e295052010-01-25 22:35:08 +00003427void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
3428 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003429 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003430}
3431
Daniel Dunbar4e295052010-01-25 22:35:08 +00003432void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
3433 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003434 // The type is good enough.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003435}
3436
Daniel Dunbar4e295052010-01-25 22:35:08 +00003437void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
3438 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003439 const Driver &D = getToolChain().getDriver();
3440
Daniel Dunbar4e295052010-01-25 22:35:08 +00003441 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00003442 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
3443 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00003444 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003445 else {
3446 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003447 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003448 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003449
Daniel Dunbar4e295052010-01-25 22:35:08 +00003450 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003451 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003452}
3453
Daniel Dunbar4e295052010-01-25 22:35:08 +00003454void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
3455 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003456 CmdArgs.push_back("-c");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003457}
Daniel Dunbara3246a02009-03-18 08:07:30 +00003458
Daniel Dunbar4e295052010-01-25 22:35:08 +00003459void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
3460 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003461 // The types are (hopefully) good enough.
3462}
3463
Tony Linthicum76329bf2011-12-12 21:14:55 +00003464// Hexagon tools start.
3465void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
3466 ArgStringList &CmdArgs) const {
3467
3468}
3469void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3470 const InputInfo &Output,
3471 const InputInfoList &Inputs,
3472 const ArgList &Args,
3473 const char *LinkingOutput) const {
3474
3475 const Driver &D = getToolChain().getDriver();
3476 ArgStringList CmdArgs;
3477
3478 std::string MarchString = "-march=";
3479 MarchString += getHexagonTargetCPU(Args);
3480 CmdArgs.push_back(Args.MakeArgString(MarchString));
3481
3482 RenderExtraToolArgs(JA, CmdArgs);
3483
3484 if (Output.isFilename()) {
3485 CmdArgs.push_back("-o");
3486 CmdArgs.push_back(Output.getFilename());
3487 } else {
3488 assert(Output.isNothing() && "Unexpected output");
3489 CmdArgs.push_back("-fsyntax-only");
3490 }
3491
3492
3493 // Only pass -x if gcc will understand it; otherwise hope gcc
3494 // understands the suffix correctly. The main use case this would go
3495 // wrong in is for linker inputs if they happened to have an odd
3496 // suffix; really the only way to get this to happen is a command
3497 // like '-x foobar a.c' which will treat a.c like a linker input.
3498 //
3499 // FIXME: For the linker case specifically, can we safely convert
3500 // inputs into '-Wl,' options?
3501 for (InputInfoList::const_iterator
3502 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3503 const InputInfo &II = *it;
3504
3505 // Don't try to pass LLVM or AST inputs to a generic gcc.
3506 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3507 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3508 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3509 << getToolChain().getTripleString();
3510 else if (II.getType() == types::TY_AST)
3511 D.Diag(clang::diag::err_drv_no_ast_support)
3512 << getToolChain().getTripleString();
3513
3514 if (II.isFilename())
3515 CmdArgs.push_back(II.getFilename());
3516 else
3517 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3518 II.getInputArg().render(Args, CmdArgs);
3519 }
3520
3521 const char *GCCName = "hexagon-as";
3522 const char *Exec =
3523 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3524 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3525
3526}
3527void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
3528 ArgStringList &CmdArgs) const {
3529 // The types are (hopefully) good enough.
3530}
3531
3532void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
3533 const InputInfo &Output,
3534 const InputInfoList &Inputs,
3535 const ArgList &Args,
3536 const char *LinkingOutput) const {
3537
3538 const Driver &D = getToolChain().getDriver();
3539 ArgStringList CmdArgs;
3540
3541 for (ArgList::const_iterator
3542 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
3543 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00003544 if (forwardToGCC(A->getOption())) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00003545 // Don't forward any -g arguments to assembly steps.
3546 if (isa<AssembleJobAction>(JA) &&
3547 A->getOption().matches(options::OPT_g_Group))
3548 continue;
3549
3550 // It is unfortunate that we have to claim here, as this means
3551 // we will basically never report anything interesting for
3552 // platforms using a generic gcc, even if we are just using gcc
3553 // to get to the assembler.
3554 A->claim();
3555 A->render(Args, CmdArgs);
3556 }
3557 }
3558
3559 RenderExtraToolArgs(JA, CmdArgs);
3560
3561 // Add Arch Information
3562 Arg *A;
Sebastian Pop86500282012-01-13 20:37:10 +00003563 if ((A = getLastHexagonArchArg(Args))) {
3564 if (A->getOption().matches(options::OPT_m_Joined))
3565 A->render(Args, CmdArgs);
Tony Linthicum76329bf2011-12-12 21:14:55 +00003566 else
Sebastian Pop86500282012-01-13 20:37:10 +00003567 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args)));
Tony Linthicum76329bf2011-12-12 21:14:55 +00003568 }
Sebastian Pop86500282012-01-13 20:37:10 +00003569 else {
3570 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args)));
3571 }
3572
Tony Linthicum76329bf2011-12-12 21:14:55 +00003573 CmdArgs.push_back("-mqdsp6-compat");
3574
3575 const char *GCCName;
3576 if (C.getDriver().CCCIsCXX)
3577 GCCName = "hexagon-g++";
3578 else
3579 GCCName = "hexagon-gcc";
3580 const char *Exec =
3581 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3582
3583 if (Output.isFilename()) {
3584 CmdArgs.push_back("-o");
3585 CmdArgs.push_back(Output.getFilename());
3586 }
3587
3588 for (InputInfoList::const_iterator
3589 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3590 const InputInfo &II = *it;
3591
3592 // Don't try to pass LLVM or AST inputs to a generic gcc.
3593 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3594 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3595 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3596 << getToolChain().getTripleString();
3597 else if (II.getType() == types::TY_AST)
3598 D.Diag(clang::diag::err_drv_no_ast_support)
3599 << getToolChain().getTripleString();
3600
3601 if (II.isFilename())
3602 CmdArgs.push_back(II.getFilename());
3603 else
3604 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3605 II.getInputArg().render(Args, CmdArgs);
3606 }
3607 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3608
3609}
3610// Hexagon tools end.
3611
Rafael Espindoladcbf6982012-10-31 18:51:07 +00003612llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
3613 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
3614 // archs which Darwin doesn't use.
3615
3616 // The matching this routine does is fairly pointless, since it is neither the
3617 // complete architecture list, nor a reasonable subset. The problem is that
3618 // historically the driver driver accepts this and also ties its -march=
3619 // handling to the architecture name, so we need to be careful before removing
3620 // support for it.
3621
3622 // This code must be kept in sync with Clang's Darwin specific argument
3623 // translation.
3624
3625 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
3626 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
3627 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
3628 .Case("ppc64", llvm::Triple::ppc64)
3629 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
3630 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
3631 llvm::Triple::x86)
3632 .Case("x86_64", llvm::Triple::x86_64)
3633 // This is derived from the driver driver.
3634 .Cases("arm", "armv4t", "armv5", "armv6", llvm::Triple::arm)
3635 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", llvm::Triple::arm)
3636 .Case("r600", llvm::Triple::r600)
3637 .Case("nvptx", llvm::Triple::nvptx)
3638 .Case("nvptx64", llvm::Triple::nvptx64)
3639 .Case("amdil", llvm::Triple::amdil)
3640 .Case("spir", llvm::Triple::spir)
3641 .Default(llvm::Triple::UnknownArch);
3642}
Tony Linthicum76329bf2011-12-12 21:14:55 +00003643
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003644const char *darwin::CC1::getCC1Name(types::ID Type) const {
3645 switch (Type) {
3646 default:
3647 llvm_unreachable("Unexpected type for Darwin CC1 tool.");
3648 case types::TY_Asm:
3649 case types::TY_C: case types::TY_CHeader:
3650 case types::TY_PP_C: case types::TY_PP_CHeader:
3651 return "cc1";
3652 case types::TY_ObjC: case types::TY_ObjCHeader:
3653 case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias:
3654 case types::TY_PP_ObjCHeader:
3655 return "cc1obj";
3656 case types::TY_CXX: case types::TY_CXXHeader:
3657 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
3658 return "cc1plus";
3659 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
3660 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias:
3661 case types::TY_PP_ObjCXXHeader:
3662 return "cc1objplus";
3663 }
3664}
3665
3666void darwin::CC1::anchor() {}
3667
3668const char *darwin::CC1::getBaseInputName(const ArgList &Args,
3669 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00003670 return Args.MakeArgString(
3671 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003672}
3673
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003674const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
3675 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003676 const char *Str = getBaseInputName(Args, Inputs);
3677
Chris Lattner906bb902011-01-16 08:14:11 +00003678 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003679 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003680
3681 return Str;
3682}
3683
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003684const char *
3685darwin::CC1::getDependencyFileName(const ArgList &Args,
3686 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003687 // FIXME: Think about this more.
3688 std::string Res;
3689
3690 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003691 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003692 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003693 } else {
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003694 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003695 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00003696 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00003697}
3698
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003699void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const {
3700 for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end();
3701 it != ie;) {
3702
3703 StringRef Option = *it;
3704 bool RemoveOption = false;
3705
3706 // Erase both -fmodule-cache-path and its argument.
3707 if (Option.equals("-fmodule-cache-path") && it+2 != ie) {
3708 it = CmdArgs.erase(it, it+2);
3709 ie = CmdArgs.end();
3710 continue;
3711 }
3712
3713 // Remove unsupported -f options.
3714 if (Option.startswith("-f")) {
3715 // Remove -f/-fno- to reduce the number of cases.
3716 if (Option.startswith("-fno-"))
3717 Option = Option.substr(5);
3718 else
3719 Option = Option.substr(2);
3720 RemoveOption = llvm::StringSwitch<bool>(Option)
3721 .Case("altivec", true)
3722 .Case("modules", true)
3723 .Case("diagnostics-show-note-include-stack", true)
3724 .Default(false);
3725 }
3726
3727 // Handle machine specific options.
3728 if (Option.startswith("-m")) {
3729 RemoveOption = llvm::StringSwitch<bool>(Option)
3730 .Case("-mthumb", true)
3731 .Case("-mno-thumb", true)
3732 .Case("-mno-fused-madd", true)
3733 .Case("-mlong-branch", true)
3734 .Case("-mlongcall", true)
3735 .Case("-mcpu=G4", true)
3736 .Case("-mcpu=G5", true)
3737 .Default(false);
3738 }
3739
3740 // Handle warning options.
3741 if (Option.startswith("-W")) {
3742 // Remove -W/-Wno- to reduce the number of cases.
3743 if (Option.startswith("-Wno-"))
3744 Option = Option.substr(5);
3745 else
3746 Option = Option.substr(2);
3747
3748 RemoveOption = llvm::StringSwitch<bool>(Option)
3749 .Case("address-of-temporary", true)
3750 .Case("ambiguous-member-template", true)
3751 .Case("analyzer-incompatible-plugin", true)
3752 .Case("array-bounds", true)
3753 .Case("array-bounds-pointer-arithmetic", true)
3754 .Case("bind-to-temporary-copy", true)
3755 .Case("bitwise-op-parentheses", true)
3756 .Case("bool-conversions", true)
3757 .Case("builtin-macro-redefined", true)
3758 .Case("c++-hex-floats", true)
3759 .Case("c++0x-compat", true)
3760 .Case("c++0x-extensions", true)
3761 .Case("c++0x-narrowing", true)
3762 .Case("c++11-compat", true)
3763 .Case("c++11-extensions", true)
3764 .Case("c++11-narrowing", true)
3765 .Case("conditional-uninitialized", true)
3766 .Case("constant-conversion", true)
3767 .Case("conversion-null", true)
3768 .Case("CFString-literal", true)
3769 .Case("constant-logical-operand", true)
3770 .Case("custom-atomic-properties", true)
3771 .Case("default-arg-special-member", true)
3772 .Case("delegating-ctor-cycles", true)
3773 .Case("delete-non-virtual-dtor", true)
3774 .Case("deprecated-implementations", true)
3775 .Case("deprecated-writable-strings", true)
3776 .Case("distributed-object-modifiers", true)
3777 .Case("duplicate-method-arg", true)
3778 .Case("dynamic-class-memaccess", true)
3779 .Case("enum-compare", true)
3780 .Case("enum-conversion", true)
3781 .Case("exit-time-destructors", true)
3782 .Case("gnu", true)
3783 .Case("gnu-designator", true)
3784 .Case("header-hygiene", true)
3785 .Case("idiomatic-parentheses", true)
3786 .Case("ignored-qualifiers", true)
3787 .Case("implicit-atomic-properties", true)
3788 .Case("incompatible-pointer-types", true)
3789 .Case("incomplete-implementation", true)
3790 .Case("int-conversion", true)
3791 .Case("initializer-overrides", true)
3792 .Case("invalid-noreturn", true)
3793 .Case("invalid-token-paste", true)
3794 .Case("language-extension-token", true)
3795 .Case("literal-conversion", true)
3796 .Case("literal-range", true)
3797 .Case("local-type-template-args", true)
3798 .Case("logical-op-parentheses", true)
3799 .Case("method-signatures", true)
3800 .Case("microsoft", true)
3801 .Case("mismatched-tags", true)
3802 .Case("missing-method-return-type", true)
3803 .Case("non-pod-varargs", true)
3804 .Case("nonfragile-abi2", true)
3805 .Case("null-arithmetic", true)
3806 .Case("null-dereference", true)
3807 .Case("out-of-line-declaration", true)
3808 .Case("overriding-method-mismatch", true)
3809 .Case("readonly-setter-attrs", true)
3810 .Case("return-stack-address", true)
3811 .Case("self-assign", true)
3812 .Case("semicolon-before-method-body", true)
3813 .Case("sentinel", true)
3814 .Case("shift-overflow", true)
3815 .Case("shift-sign-overflow", true)
3816 .Case("sign-conversion", true)
3817 .Case("sizeof-array-argument", true)
3818 .Case("sizeof-pointer-memaccess", true)
3819 .Case("string-compare", true)
3820 .Case("super-class-method-mismatch", true)
3821 .Case("tautological-compare", true)
3822 .Case("typedef-redefinition", true)
3823 .Case("typename-missing", true)
3824 .Case("undefined-reinterpret-cast", true)
3825 .Case("unknown-warning-option", true)
3826 .Case("unnamed-type-template-args", true)
3827 .Case("unneeded-internal-declaration", true)
3828 .Case("unneeded-member-function", true)
3829 .Case("unused-comparison", true)
3830 .Case("unused-exception-parameter", true)
3831 .Case("unused-member-function", true)
3832 .Case("unused-result", true)
3833 .Case("vector-conversions", true)
3834 .Case("vla", true)
3835 .Case("used-but-marked-unused", true)
3836 .Case("weak-vtables", true)
3837 .Default(false);
3838 } // if (Option.startswith("-W"))
3839 if (RemoveOption) {
3840 it = CmdArgs.erase(it);
3841 ie = CmdArgs.end();
3842 } else {
3843 ++it;
3844 }
3845 }
3846}
3847
3848void darwin::CC1::AddCC1Args(const ArgList &Args,
3849 ArgStringList &CmdArgs) const {
3850 const Driver &D = getToolChain().getDriver();
3851
3852 CheckCodeGenerationOptions(D, Args);
3853
3854 // Derived from cc1 spec.
3855 if ((!Args.hasArg(options::OPT_mkernel) ||
3856 (getDarwinToolChain().isTargetIPhoneOS() &&
3857 !getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) &&
3858 !Args.hasArg(options::OPT_static) &&
3859 !Args.hasArg(options::OPT_mdynamic_no_pic))
3860 CmdArgs.push_back("-fPIC");
3861
3862 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3863 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
3864 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3865 CmdArgs.push_back("-fno-builtin-strcat");
3866 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3867 CmdArgs.push_back("-fno-builtin-strcpy");
3868 }
3869
3870 if (Args.hasArg(options::OPT_g_Flag) &&
3871 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
3872 CmdArgs.push_back("-feliminate-unused-debug-symbols");
3873}
3874
3875void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
3876 const InputInfoList &Inputs,
3877 const ArgStringList &OutputArgs) const {
3878 const Driver &D = getToolChain().getDriver();
3879
3880 // Derived from cc1_options spec.
3881 if (Args.hasArg(options::OPT_fast) ||
3882 Args.hasArg(options::OPT_fastf) ||
3883 Args.hasArg(options::OPT_fastcp))
3884 CmdArgs.push_back("-O3");
3885
3886 if (Arg *A = Args.getLastArg(options::OPT_pg))
3887 if (Args.hasArg(options::OPT_fomit_frame_pointer))
3888 D.Diag(diag::err_drv_argument_not_allowed_with)
3889 << A->getAsString(Args) << "-fomit-frame-pointer";
3890
3891 AddCC1Args(Args, CmdArgs);
3892
3893 if (!Args.hasArg(options::OPT_Q))
3894 CmdArgs.push_back("-quiet");
3895
3896 CmdArgs.push_back("-dumpbase");
3897 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
3898
3899 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
3900
3901 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
3902 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
3903
3904 // FIXME: The goal is to use the user provided -o if that is our
3905 // final output, otherwise to drive from the original input
3906 // name. Find a clean way to go about this.
3907 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
3908 Args.hasArg(options::OPT_o)) {
3909 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
3910 CmdArgs.push_back("-auxbase-strip");
3911 CmdArgs.push_back(OutputOpt->getValue());
3912 } else {
3913 CmdArgs.push_back("-auxbase");
3914 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
3915 }
3916
3917 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
3918
3919 Args.AddAllArgs(CmdArgs, options::OPT_O);
3920 // FIXME: -Wall is getting some special treatment. Investigate.
3921 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
3922 Args.AddLastArg(CmdArgs, options::OPT_w);
3923 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
3924 options::OPT_trigraphs);
3925 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3926 // Honor -std-default.
3927 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3928 "-std=", /*Joined=*/true);
3929 }
3930
3931 if (Args.hasArg(options::OPT_v))
3932 CmdArgs.push_back("-version");
3933 if (Args.hasArg(options::OPT_pg) &&
3934 getToolChain().SupportsProfiling())
3935 CmdArgs.push_back("-p");
3936 Args.AddLastArg(CmdArgs, options::OPT_p);
3937
3938 // The driver treats -fsyntax-only specially.
3939 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3940 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
3941 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
3942 // used to inhibit the default -fno-builtin-str{cat,cpy}.
3943 //
3944 // FIXME: Should we grow a better way to deal with "removing" args?
3945 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
3946 options::OPT_fsyntax_only),
3947 ie = Args.filtered_end(); it != ie; ++it) {
3948 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
3949 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
3950 (*it)->claim();
3951 (*it)->render(Args, CmdArgs);
3952 }
3953 }
3954 } else
3955 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
3956
3957 // Claim Clang only -f options, they aren't worth warning about.
3958 Args.ClaimAllArgs(options::OPT_f_clang_Group);
3959
3960 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3961 if (Args.hasArg(options::OPT_Qn))
3962 CmdArgs.push_back("-fno-ident");
3963
3964 // FIXME: This isn't correct.
3965 //Args.AddLastArg(CmdArgs, options::OPT__help)
3966 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
3967
3968 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3969
3970 // FIXME: Still don't get what is happening here. Investigate.
3971 Args.AddAllArgs(CmdArgs, options::OPT__param);
3972
3973 if (Args.hasArg(options::OPT_fmudflap) ||
3974 Args.hasArg(options::OPT_fmudflapth)) {
3975 CmdArgs.push_back("-fno-builtin");
3976 CmdArgs.push_back("-fno-merge-constants");
3977 }
3978
3979 if (Args.hasArg(options::OPT_coverage)) {
3980 CmdArgs.push_back("-fprofile-arcs");
3981 CmdArgs.push_back("-ftest-coverage");
3982 }
3983
3984 if (types::isCXX(Inputs[0].getType()))
3985 CmdArgs.push_back("-D__private_extern__=extern");
3986}
3987
3988void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
3989 const InputInfoList &Inputs,
3990 const ArgStringList &OutputArgs) const {
3991 // Derived from cpp_options
3992 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
3993
3994 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3995
3996 AddCC1Args(Args, CmdArgs);
3997
3998 // NOTE: The code below has some commonality with cpp_options, but
3999 // in classic gcc style ends up sending things in different
4000 // orders. This may be a good merge candidate once we drop pedantic
4001 // compatibility.
4002
4003 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
4004 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
4005 options::OPT_trigraphs);
4006 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
4007 // Honor -std-default.
4008 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
4009 "-std=", /*Joined=*/true);
4010 }
4011 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
4012 Args.AddLastArg(CmdArgs, options::OPT_w);
4013
4014 // The driver treats -fsyntax-only specially.
4015 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
4016
4017 // Claim Clang only -f options, they aren't worth warning about.
4018 Args.ClaimAllArgs(options::OPT_f_clang_Group);
4019
4020 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
4021 !Args.hasArg(options::OPT_fno_working_directory))
4022 CmdArgs.push_back("-fworking-directory");
4023
4024 Args.AddAllArgs(CmdArgs, options::OPT_O);
4025 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4026 if (Args.hasArg(options::OPT_save_temps))
4027 CmdArgs.push_back("-fpch-preprocess");
4028}
4029
4030void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
4031 ArgStringList &CmdArgs,
4032 const InputInfoList &Inputs) const {
4033 const Driver &D = getToolChain().getDriver();
4034
4035 CheckPreprocessingOptions(D, Args);
4036
4037 // Derived from cpp_unique_options.
4038 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
4039 Args.AddLastArg(CmdArgs, options::OPT_C);
4040 Args.AddLastArg(CmdArgs, options::OPT_CC);
4041 if (!Args.hasArg(options::OPT_Q))
4042 CmdArgs.push_back("-quiet");
4043 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
4044 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
4045 Args.AddLastArg(CmdArgs, options::OPT_v);
4046 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
4047 Args.AddLastArg(CmdArgs, options::OPT_P);
4048
4049 // FIXME: Handle %I properly.
4050 if (getToolChain().getArch() == llvm::Triple::x86_64) {
4051 CmdArgs.push_back("-imultilib");
4052 CmdArgs.push_back("x86_64");
4053 }
4054
4055 if (Args.hasArg(options::OPT_MD)) {
4056 CmdArgs.push_back("-MD");
4057 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
4058 }
4059
4060 if (Args.hasArg(options::OPT_MMD)) {
4061 CmdArgs.push_back("-MMD");
4062 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
4063 }
4064
4065 Args.AddLastArg(CmdArgs, options::OPT_M);
4066 Args.AddLastArg(CmdArgs, options::OPT_MM);
4067 Args.AddAllArgs(CmdArgs, options::OPT_MF);
4068 Args.AddLastArg(CmdArgs, options::OPT_MG);
4069 Args.AddLastArg(CmdArgs, options::OPT_MP);
4070 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
4071 Args.AddAllArgs(CmdArgs, options::OPT_MT);
4072 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
4073 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
4074 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4075 CmdArgs.push_back("-MQ");
4076 CmdArgs.push_back(OutputOpt->getValue());
4077 }
4078 }
4079
4080 Args.AddLastArg(CmdArgs, options::OPT_remap);
4081 if (Args.hasArg(options::OPT_g3))
4082 CmdArgs.push_back("-dD");
4083 Args.AddLastArg(CmdArgs, options::OPT_H);
4084
4085 AddCPPArgs(Args, CmdArgs);
4086
4087 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
4088 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
4089
4090 for (InputInfoList::const_iterator
4091 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4092 const InputInfo &II = *it;
4093
4094 CmdArgs.push_back(II.getFilename());
4095 }
4096
4097 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
4098 options::OPT_Xpreprocessor);
4099
4100 if (Args.hasArg(options::OPT_fmudflap)) {
4101 CmdArgs.push_back("-D_MUDFLAP");
4102 CmdArgs.push_back("-include");
4103 CmdArgs.push_back("mf-runtime.h");
4104 }
4105
4106 if (Args.hasArg(options::OPT_fmudflapth)) {
4107 CmdArgs.push_back("-D_MUDFLAP");
4108 CmdArgs.push_back("-D_MUDFLAPTH");
4109 CmdArgs.push_back("-include");
4110 CmdArgs.push_back("mf-runtime.h");
4111 }
4112}
4113
4114void darwin::CC1::AddCPPArgs(const ArgList &Args,
4115 ArgStringList &CmdArgs) const {
4116 // Derived from cpp spec.
4117
4118 if (Args.hasArg(options::OPT_static)) {
4119 // The gcc spec is broken here, it refers to dynamic but
4120 // that has been translated. Start by being bug compatible.
4121
4122 // if (!Args.hasArg(arglist.parser.dynamicOption))
4123 CmdArgs.push_back("-D__STATIC__");
4124 } else
4125 CmdArgs.push_back("-D__DYNAMIC__");
4126
4127 if (Args.hasArg(options::OPT_pthread))
4128 CmdArgs.push_back("-D_REENTRANT");
4129}
4130
4131void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
4132 const InputInfo &Output,
4133 const InputInfoList &Inputs,
4134 const ArgList &Args,
4135 const char *LinkingOutput) const {
4136 ArgStringList CmdArgs;
4137
4138 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
4139
4140 CmdArgs.push_back("-E");
4141
4142 if (Args.hasArg(options::OPT_traditional) ||
4143 Args.hasArg(options::OPT_traditional_cpp))
4144 CmdArgs.push_back("-traditional-cpp");
4145
4146 ArgStringList OutputArgs;
4147 assert(Output.isFilename() && "Unexpected CC1 output.");
4148 OutputArgs.push_back("-o");
4149 OutputArgs.push_back(Output.getFilename());
4150
4151 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
4152 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
4153 } else {
4154 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
4155 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
4156 }
4157
4158 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
4159
4160 RemoveCC1UnsupportedArgs(CmdArgs);
4161
4162 const char *CC1Name = getCC1Name(Inputs[0].getType());
4163 const char *Exec =
4164 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
4165 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4166}
4167
4168void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
4169 const InputInfo &Output,
4170 const InputInfoList &Inputs,
4171 const ArgList &Args,
4172 const char *LinkingOutput) const {
4173 const Driver &D = getToolChain().getDriver();
4174 ArgStringList CmdArgs;
4175
4176 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
4177
4178 // Silence warning about unused --serialize-diagnostics
4179 Args.ClaimAllArgs(options::OPT__serialize_diags);
4180
4181 types::ID InputType = Inputs[0].getType();
4182 if (const Arg *A = Args.getLastArg(options::OPT_traditional))
4183 D.Diag(diag::err_drv_argument_only_allowed_with)
4184 << A->getAsString(Args) << "-E";
4185
4186 if (JA.getType() == types::TY_LLVM_IR ||
4187 JA.getType() == types::TY_LTO_IR)
4188 CmdArgs.push_back("-emit-llvm");
4189 else if (JA.getType() == types::TY_LLVM_BC ||
4190 JA.getType() == types::TY_LTO_BC)
4191 CmdArgs.push_back("-emit-llvm-bc");
4192 else if (Output.getType() == types::TY_AST)
4193 D.Diag(diag::err_drv_no_ast_support)
4194 << getToolChain().getTripleString();
4195 else if (JA.getType() != types::TY_PP_Asm &&
4196 JA.getType() != types::TY_PCH)
4197 D.Diag(diag::err_drv_invalid_gcc_output_type)
4198 << getTypeName(JA.getType());
4199
4200 ArgStringList OutputArgs;
4201 if (Output.getType() != types::TY_PCH) {
4202 OutputArgs.push_back("-o");
4203 if (Output.isNothing())
4204 OutputArgs.push_back("/dev/null");
4205 else
4206 OutputArgs.push_back(Output.getFilename());
4207 }
4208
4209 // There is no need for this level of compatibility, but it makes
4210 // diffing easier.
4211 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
4212 Args.hasArg(options::OPT_S));
4213
4214 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
4215 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
4216 if (OutputArgsEarly) {
4217 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
4218 } else {
4219 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
4220 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
4221 }
4222 } else {
4223 CmdArgs.push_back("-fpreprocessed");
4224
4225 for (InputInfoList::const_iterator
4226 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4227 const InputInfo &II = *it;
4228
4229 // Reject AST inputs.
4230 if (II.getType() == types::TY_AST) {
4231 D.Diag(diag::err_drv_no_ast_support)
4232 << getToolChain().getTripleString();
4233 return;
4234 }
4235
4236 CmdArgs.push_back(II.getFilename());
4237 }
4238
4239 if (OutputArgsEarly) {
4240 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
4241 } else {
4242 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
4243 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
4244 }
4245 }
4246
4247 if (Output.getType() == types::TY_PCH) {
4248 assert(Output.isFilename() && "Invalid PCH output.");
4249
4250 CmdArgs.push_back("-o");
4251 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
4252 // to be a good reason.
4253 const char *TmpPath = C.getArgs().MakeArgString(
4254 D.GetTemporaryPath("cc", "s"));
4255 C.addTempFile(TmpPath);
4256 CmdArgs.push_back(TmpPath);
4257
4258 // If we're emitting a pch file with the last 4 characters of ".pth"
4259 // and falling back to llvm-gcc we want to use ".gch" instead.
4260 std::string OutputFile(Output.getFilename());
4261 size_t loc = OutputFile.rfind(".pth");
4262 if (loc != std::string::npos)
4263 OutputFile.replace(loc, 4, ".gch");
4264 const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile);
4265 CmdArgs.push_back(Tmp);
4266 }
4267
4268 RemoveCC1UnsupportedArgs(CmdArgs);
4269
4270 const char *CC1Name = getCC1Name(Inputs[0].getType());
4271 const char *Exec =
4272 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
4273 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4274}
4275
Daniel Dunbarbe220842009-03-20 16:06:39 +00004276void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004277 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004278 const InputInfoList &Inputs,
4279 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00004280 const char *LinkingOutput) const {
4281 ArgStringList CmdArgs;
4282
4283 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4284 const InputInfo &Input = Inputs[0];
4285
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004286 // Determine the original source input.
4287 const Action *SourceAction = &JA;
4288 while (SourceAction->getKind() != Action::InputClass) {
4289 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4290 SourceAction = SourceAction->getInputs()[0];
4291 }
4292
4293 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00004294 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004295 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004296 if (Args.hasArg(options::OPT_gstabs))
4297 CmdArgs.push_back("--gstabs");
4298 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00004299 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004300 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004301
Daniel Dunbarbe220842009-03-20 16:06:39 +00004302 // Derived from asm spec.
Daniel Dunbar3571dd92009-09-09 18:36:27 +00004303 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00004304
Daniel Dunbar6d484762010-07-22 01:47:22 +00004305 // Use -force_cpusubtype_ALL on x86 by default.
4306 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
4307 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00004308 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4309 CmdArgs.push_back("-force_cpusubtype_ALL");
4310
Daniel Dunbara6b4a3d2009-08-24 22:26:16 +00004311 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004312 (((Args.hasArg(options::OPT_mkernel) ||
4313 Args.hasArg(options::OPT_fapple_kext)) &&
4314 (!getDarwinToolChain().isTargetIPhoneOS() ||
4315 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4316 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004317 CmdArgs.push_back("-static");
4318
Daniel Dunbarbe220842009-03-20 16:06:39 +00004319 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4320 options::OPT_Xassembler);
4321
4322 assert(Output.isFilename() && "Unexpected lipo output.");
4323 CmdArgs.push_back("-o");
4324 CmdArgs.push_back(Output.getFilename());
4325
Daniel Dunbarb440f562010-08-02 02:38:21 +00004326 assert(Input.isFilename() && "Invalid input.");
4327 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00004328
4329 // asm_final spec is empty.
4330
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004331 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004332 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004333 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00004334}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004335
David Blaikie68e081d2011-12-20 02:48:34 +00004336void darwin::DarwinTool::anchor() {}
4337
Daniel Dunbare9ded432009-09-09 18:36:20 +00004338void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4339 ArgStringList &CmdArgs) const {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004340 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00004341
Daniel Dunbarc1964212009-03-26 16:23:12 +00004342 // Derived from darwin_arch spec.
4343 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00004344 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00004345
Daniel Dunbardcc3b652010-01-22 02:04:58 +00004346 // FIXME: Is this needed anymore?
4347 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00004348 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00004349}
4350
Bill Wendling3b2000f2012-10-02 18:02:50 +00004351bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4352 // We only need to generate a temp path for LTO if we aren't compiling object
4353 // files. When compiling source files, we run 'dsymutil' after linking. We
4354 // don't run 'dsymutil' when compiling object files.
4355 for (InputInfoList::const_iterator
4356 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4357 if (it->getType() != types::TY_Object)
4358 return true;
4359
4360 return false;
4361}
4362
Daniel Dunbarccbc4522010-09-09 21:51:05 +00004363void darwin::Link::AddLinkArgs(Compilation &C,
4364 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00004365 ArgStringList &CmdArgs,
4366 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004367 const Driver &D = getToolChain().getDriver();
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004368 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00004369
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004370 unsigned Version[3] = { 0, 0, 0 };
4371 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4372 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00004373 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004374 Version[1], Version[2], HadExtra) ||
4375 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004376 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004377 << A->getAsString(Args);
4378 }
4379
4380 // Newer linkers support -demangle, pass it if supported and not disabled by
4381 // the user.
Daniel Dunbarecb41cb2012-01-04 21:45:27 +00004382 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00004383 // Don't pass -demangle to ld_classic.
4384 //
4385 // FIXME: This is a temporary workaround, ld should be handling this.
4386 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4387 Args.hasArg(options::OPT_static));
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00004388 if (getToolChain().getArch() == llvm::Triple::x86) {
4389 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4390 options::OPT_Wl_COMMA),
4391 ie = Args.filtered_end(); it != ie; ++it) {
4392 const Arg *A = *it;
4393 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Richard Smithbd55daf2012-11-01 04:30:05 +00004394 if (StringRef(A->getValue(i)) == "-kext")
Daniel Dunbar3d7e0e22010-09-07 17:50:41 +00004395 UsesLdClassic = true;
4396 }
4397 }
Daniel Dunbar1eaf5c62010-09-07 17:07:49 +00004398 if (!UsesLdClassic)
4399 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00004400 }
4401
Bill Wendling744611f2012-11-13 00:54:24 +00004402 if (Version[0] >= 116 && D.IsUsingLTO(Args)) {
4403 if (NeedsTempPath(Inputs)) {
4404 // If we are using LTO, then automatically create a temporary file path
4405 // for the linker to use, so that it's lifetime will extend past a
4406 // possible dsymutil step.
4407 const char *TmpPath = C.getArgs().MakeArgString(
4408 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4409 C.addTempFile(TmpPath);
4410 CmdArgs.push_back("-object_path_lto");
4411 CmdArgs.push_back(TmpPath);
4412 }
4413
4414 // FIXME: Disable the creation of accelerator tables when using LTO. They
4415 // don't currently work and can cause other tools to bork.
4416 CmdArgs.push_back("-mllvm");
4417 CmdArgs.push_back("-dwarf-accel-tables=Disable");
Daniel Dunbaref889c72011-06-21 20:55:11 +00004418 }
4419
Daniel Dunbarc1964212009-03-26 16:23:12 +00004420 // Derived from the "link" spec.
4421 Args.AddAllArgs(CmdArgs, options::OPT_static);
4422 if (!Args.hasArg(options::OPT_static))
4423 CmdArgs.push_back("-dynamic");
4424 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4425 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4426 // here. How do we wish to handle such things?
4427 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004428
Daniel Dunbarc1964212009-03-26 16:23:12 +00004429 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara48823f2010-01-22 02:04:52 +00004430 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00004431 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00004432 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004433
4434 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4435 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4436 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4437
4438 Arg *A;
4439 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4440 (A = Args.getLastArg(options::OPT_current__version)) ||
4441 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004442 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00004443 << A->getAsString(Args) << "-dynamiclib";
4444
4445 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4446 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4447 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4448 } else {
4449 CmdArgs.push_back("-dylib");
4450
4451 Arg *A;
4452 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4453 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4454 (A = Args.getLastArg(options::OPT_client__name)) ||
4455 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4456 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4457 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004458 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00004459 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004460
Daniel Dunbarc1964212009-03-26 16:23:12 +00004461 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4462 "-dylib_compatibility_version");
4463 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4464 "-dylib_current_version");
4465
Daniel Dunbara48823f2010-01-22 02:04:52 +00004466 AddDarwinArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004467
4468 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4469 "-dylib_install_name");
4470 }
4471
4472 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4473 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4474 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004475 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004476 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004477 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4478 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4479 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4480 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4481 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4482 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00004483 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004484 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4485 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4486 Args.AddAllArgs(CmdArgs, options::OPT_init);
4487
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004488 // Add the deployment target.
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00004489 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
Daniel Dunbar72ceb922011-04-30 04:22:58 +00004490
4491 // If we had an explicit -mios-simulator-version-min argument, honor that,
4492 // otherwise use the traditional deployment targets. We can't just check the
4493 // is-sim attribute because existing code follows this path, and the linker
4494 // may not handle the argument.
4495 //
4496 // FIXME: We may be able to remove this, once we can verify no one depends on
4497 // it.
4498 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4499 CmdArgs.push_back("-ios_simulator_version_min");
4500 else if (DarwinTC.isTargetIPhoneOS())
4501 CmdArgs.push_back("-iphoneos_version_min");
4502 else
4503 CmdArgs.push_back("-macosx_version_min");
Benjamin Kramerddefa6d2012-03-10 20:55:36 +00004504 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
Daniel Dunbarc44d3132011-04-28 21:23:41 +00004505
Daniel Dunbarc1964212009-03-26 16:23:12 +00004506 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4507 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4508 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4509 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4510 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004511
Daniel Dunbaraf68a882010-07-13 23:31:40 +00004512 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4513 options::OPT_fno_pie,
4514 options::OPT_fno_PIE)) {
4515 if (A->getOption().matches(options::OPT_fpie) ||
4516 A->getOption().matches(options::OPT_fPIE))
4517 CmdArgs.push_back("-pie");
4518 else
4519 CmdArgs.push_back("-no_pie");
4520 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004521
4522 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4523 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4524 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4525 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4526 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4527 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4528 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4529 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4530 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4531 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4532 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4533 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4534 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4535 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4536 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4537 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004538
Daniel Dunbar84384642011-05-02 21:03:47 +00004539 // Give --sysroot= preference, over the Apple specific behavior to also use
4540 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00004541 StringRef sysroot = C.getSysRoot();
4542 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00004543 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00004544 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00004545 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4546 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00004547 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004548 }
4549
Daniel Dunbarc1964212009-03-26 16:23:12 +00004550 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4551 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4552 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4553 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4554 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00004555 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004556 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4557 Args.AddAllArgs(CmdArgs, options::OPT_y);
4558 Args.AddLastArg(CmdArgs, options::OPT_w);
4559 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4560 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4561 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4562 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4563 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4564 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4565 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4566 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4567 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4568 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4569 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4570 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4571}
4572
4573void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004574 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004575 const InputInfoList &Inputs,
4576 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00004577 const char *LinkingOutput) const {
4578 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00004579
Daniel Dunbarc1964212009-03-26 16:23:12 +00004580 // The logic here is derived from gcc's behavior; most of which
4581 // comes from specs (starting with link_command). Consult gcc for
4582 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00004583 ArgStringList CmdArgs;
4584
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00004585 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4586 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4587 options::OPT_ccc_arcmt_migrate)) {
4588 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4589 (*I)->claim();
4590 const char *Exec =
4591 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4592 CmdArgs.push_back(Output.getFilename());
4593 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4594 return;
4595 }
4596
Daniel Dunbarc1964212009-03-26 16:23:12 +00004597 // I'm not sure why this particular decomposition exists in gcc, but
4598 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00004599 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004600
Daniel Dunbarc1964212009-03-26 16:23:12 +00004601 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4602 Args.AddAllArgs(CmdArgs, options::OPT_s);
4603 Args.AddAllArgs(CmdArgs, options::OPT_t);
4604 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4605 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004606 Args.AddLastArg(CmdArgs, options::OPT_e);
4607 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4608 Args.AddAllArgs(CmdArgs, options::OPT_r);
4609
Daniel Dunbar767bbab2010-10-18 22:08:36 +00004610 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4611 // members of static archive libraries which implement Objective-C classes or
4612 // categories.
4613 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4614 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004615
Daniel Dunbarc1964212009-03-26 16:23:12 +00004616 CmdArgs.push_back("-o");
4617 CmdArgs.push_back(Output.getFilename());
4618
Chad Rosier06fd3c62012-05-16 23:45:12 +00004619 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004620 !Args.hasArg(options::OPT_nostartfiles)) {
4621 // Derived from startfile spec.
4622 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004623 // Derived from darwin_dylib1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004624 if (getDarwinToolChain().isTargetIOSSimulator()) {
4625 // The simulator doesn't have a versioned crt1 file.
4626 CmdArgs.push_back("-ldylib1.o");
4627 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004628 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4629 CmdArgs.push_back("-ldylib1.o");
4630 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004631 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbar83608032010-01-27 00:56:56 +00004632 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004633 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004634 CmdArgs.push_back("-ldylib1.10.5.o");
4635 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004636 } else {
4637 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004638 if (!Args.hasArg(options::OPT_static)) {
4639 // Derived from darwin_bundle1 spec.
Daniel Dunbar16d97092011-04-01 21:02:42 +00004640 if (getDarwinToolChain().isTargetIOSSimulator()) {
4641 // The simulator doesn't have a versioned crt1 file.
4642 CmdArgs.push_back("-lbundle1.o");
4643 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004644 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4645 CmdArgs.push_back("-lbundle1.o");
4646 } else {
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004647 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbar83608032010-01-27 00:56:56 +00004648 CmdArgs.push_back("-lbundle1.o");
4649 }
Daniel Dunbarae8bca02009-04-01 03:17:40 +00004650 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004651 } else {
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004652 if (Args.hasArg(options::OPT_pg) &&
4653 getToolChain().SupportsProfiling()) {
Daniel Dunbarc1964212009-03-26 16:23:12 +00004654 if (Args.hasArg(options::OPT_static) ||
4655 Args.hasArg(options::OPT_object) ||
4656 Args.hasArg(options::OPT_preload)) {
4657 CmdArgs.push_back("-lgcrt0.o");
4658 } else {
4659 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004660
Daniel Dunbarc1964212009-03-26 16:23:12 +00004661 // darwin_crt2 spec is empty.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004662 }
Bob Wilsonef285b42012-07-04 00:18:41 +00004663 // By default on OS X 10.8 and later, we don't link with a crt1.o
4664 // file and the linker knows to use _main as the entry point. But,
4665 // when compiling with -pg, we need to link with the gcrt1.o file,
4666 // so pass the -no_new_main option to tell the linker to use the
4667 // "start" symbol as the entry point.
Bob Wilson1e148fe2012-07-03 20:42:10 +00004668 if (getDarwinToolChain().isTargetMacOS() &&
4669 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4670 CmdArgs.push_back("-no_new_main");
Daniel Dunbarc1964212009-03-26 16:23:12 +00004671 } else {
4672 if (Args.hasArg(options::OPT_static) ||
4673 Args.hasArg(options::OPT_object) ||
4674 Args.hasArg(options::OPT_preload)) {
4675 CmdArgs.push_back("-lcrt0.o");
4676 } else {
4677 // Derived from darwin_crt1 spec.
Daniel Dunbarebc34df2011-03-31 17:12:33 +00004678 if (getDarwinToolChain().isTargetIOSSimulator()) {
4679 // The simulator doesn't have a versioned crt1 file.
4680 CmdArgs.push_back("-lcrt1.o");
4681 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbar83608032010-01-27 00:56:56 +00004682 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4683 CmdArgs.push_back("-lcrt1.o");
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004684 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
Daniel Dunbar83608032010-01-27 00:56:56 +00004685 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004686 } else {
4687 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4688 CmdArgs.push_back("-lcrt1.o");
4689 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4690 CmdArgs.push_back("-lcrt1.10.5.o");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004691 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004692 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004693
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004694 // darwin_crt2 spec is empty.
4695 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00004696 }
4697 }
4698 }
4699 }
4700
Daniel Dunbar6d23b2f2010-01-27 00:57:03 +00004701 if (!getDarwinToolChain().isTargetIPhoneOS() &&
4702 Args.hasArg(options::OPT_shared_libgcc) &&
4703 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004704 const char *Str =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004705 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004706 CmdArgs.push_back(Str);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004707 }
4708 }
4709
4710 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004711
Alexey Samsonov627b10f2012-11-06 15:09:03 +00004712 SanitizerArgs Sanitize(getToolChain().getDriver(), Args);
Alexey Samsonovcc429802012-11-16 12:53:14 +00004713 // If we're building a dynamic lib with -fsanitize=address, or
4714 // -fsanitize=undefined, unresolved symbols may appear. Mark all
4715 // of them as dynamic_lookup. Linking executables is handled in
4716 // lib/Driver/ToolChains.cpp.
4717 if (Sanitize.needsAsanRt() || Sanitize.needsUbsanRt()) {
Kostya Serebryany0b692ce2011-12-06 19:18:44 +00004718 if (Args.hasArg(options::OPT_dynamiclib) ||
4719 Args.hasArg(options::OPT_bundle)) {
4720 CmdArgs.push_back("-undefined");
4721 CmdArgs.push_back("dynamic_lookup");
4722 }
4723 }
4724
Daniel Dunbarc1964212009-03-26 16:23:12 +00004725 if (Args.hasArg(options::OPT_fopenmp))
4726 // This is more complicated in gcc...
4727 CmdArgs.push_back("-lgomp");
4728
Douglas Gregor9295df02012-05-15 21:00:27 +00004729 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4730
Bob Wilson16d93952012-05-15 18:57:39 +00004731 if (isObjCRuntimeLinked(Args) &&
4732 !Args.hasArg(options::OPT_nostdlib) &&
4733 !Args.hasArg(options::OPT_nodefaultlibs)) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004734 // Avoid linking compatibility stubs on i386 mac.
4735 if (!getDarwinToolChain().isTargetMacOS() ||
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004736 getDarwinToolChain().getArch() != llvm::Triple::x86) {
Ted Kremeneke65b0862012-03-06 20:05:56 +00004737 // If we don't have ARC or subscripting runtime support, link in the
4738 // runtime stubs. We have to do this *before* adding any of the normal
4739 // linker inputs so that its initializer gets run first.
John McCall5fb5df92012-06-20 06:18:46 +00004740 ObjCRuntime runtime =
4741 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004742 // We use arclite library for both ARC and subscripting support.
John McCall3deb1ad2012-08-21 02:47:43 +00004743 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
John McCall5fb5df92012-06-20 06:18:46 +00004744 !runtime.hasSubscripting())
Ted Kremeneke65b0862012-03-06 20:05:56 +00004745 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
Ted Kremeneke65b0862012-03-06 20:05:56 +00004746 }
Bob Wilson7dda0cd2012-04-21 00:21:42 +00004747 CmdArgs.push_back("-framework");
4748 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004749 // Link libobj.
4750 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00004751 }
John McCall31168b02011-06-15 23:02:42 +00004752
Daniel Dunbarc1964212009-03-26 16:23:12 +00004753 if (LinkingOutput) {
4754 CmdArgs.push_back("-arch_multiple");
4755 CmdArgs.push_back("-final_output");
4756 CmdArgs.push_back(LinkingOutput);
4757 }
4758
Daniel Dunbarc1964212009-03-26 16:23:12 +00004759 if (Args.hasArg(options::OPT_fnested_functions))
4760 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004761
Daniel Dunbarc1964212009-03-26 16:23:12 +00004762 if (!Args.hasArg(options::OPT_nostdlib) &&
4763 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004764 if (getToolChain().getDriver().CCCIsCXX)
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00004765 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00004766
Daniel Dunbarc1964212009-03-26 16:23:12 +00004767 // link_ssp spec is empty.
4768
Daniel Dunbar26d482a2009-09-18 08:15:03 +00004769 // Let the tool chain choose which runtime library to link.
4770 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00004771 }
4772
Chad Rosier06fd3c62012-05-16 23:45:12 +00004773 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00004774 !Args.hasArg(options::OPT_nostartfiles)) {
4775 // endfile_spec is empty.
4776 }
4777
4778 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4779 Args.AddAllArgs(CmdArgs, options::OPT_F);
4780
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004781 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004782 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004783 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00004784}
4785
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004786void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004787 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004788 const InputInfoList &Inputs,
4789 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004790 const char *LinkingOutput) const {
4791 ArgStringList CmdArgs;
4792
4793 CmdArgs.push_back("-create");
4794 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004795
4796 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004797 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00004798
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004799 for (InputInfoList::const_iterator
4800 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4801 const InputInfo &II = *it;
4802 assert(II.isFilename() && "Unexpected lipo input.");
4803 CmdArgs.push_back(II.getFilename());
4804 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004805 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004806 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004807 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00004808}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00004809
Daniel Dunbar88299622010-06-04 18:28:36 +00004810void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004811 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00004812 const InputInfoList &Inputs,
4813 const ArgList &Args,
4814 const char *LinkingOutput) const {
4815 ArgStringList CmdArgs;
4816
Daniel Dunbareb86b042011-05-09 17:23:16 +00004817 CmdArgs.push_back("-o");
4818 CmdArgs.push_back(Output.getFilename());
4819
Daniel Dunbar88299622010-06-04 18:28:36 +00004820 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4821 const InputInfo &Input = Inputs[0];
4822 assert(Input.isFilename() && "Unexpected dsymutil input.");
4823 CmdArgs.push_back(Input.getFilename());
4824
Daniel Dunbar88299622010-06-04 18:28:36 +00004825 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004826 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004827 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00004828}
4829
Eric Christopher551ef452011-08-23 17:56:55 +00004830void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
4831 const InputInfo &Output,
4832 const InputInfoList &Inputs,
4833 const ArgList &Args,
4834 const char *LinkingOutput) const {
4835 ArgStringList CmdArgs;
4836 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00004837 CmdArgs.push_back("--debug-info");
4838 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00004839 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00004840
4841 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4842 const InputInfo &Input = Inputs[0];
4843 assert(Input.isFilename() && "Unexpected verify input");
4844
4845 // Grabbing the output of the earlier dsymutil run.
4846 CmdArgs.push_back(Input.getFilename());
4847
4848 const char *Exec =
4849 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4850 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4851}
4852
David Chisnallf571cde2012-02-15 13:39:01 +00004853void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4854 const InputInfo &Output,
4855 const InputInfoList &Inputs,
4856 const ArgList &Args,
4857 const char *LinkingOutput) const {
4858 ArgStringList CmdArgs;
4859
4860 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4861 options::OPT_Xassembler);
4862
4863 CmdArgs.push_back("-o");
4864 CmdArgs.push_back(Output.getFilename());
4865
4866 for (InputInfoList::const_iterator
4867 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4868 const InputInfo &II = *it;
4869 CmdArgs.push_back(II.getFilename());
4870 }
4871
4872 const char *Exec =
4873 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4874 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4875}
4876
4877
4878void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4879 const InputInfo &Output,
4880 const InputInfoList &Inputs,
4881 const ArgList &Args,
4882 const char *LinkingOutput) const {
4883 // FIXME: Find a real GCC, don't hard-code versions here
4884 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4885 const llvm::Triple &T = getToolChain().getTriple();
4886 std::string LibPath = "/usr/lib/";
4887 llvm::Triple::ArchType Arch = T.getArch();
4888 switch (Arch) {
4889 case llvm::Triple::x86:
4890 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4891 T.getOSName()).str() + "/4.5.2/";
4892 break;
4893 case llvm::Triple::x86_64:
4894 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4895 T.getOSName()).str();
4896 GCCLibPath += "/4.5.2/amd64/";
4897 LibPath += "amd64/";
4898 break;
4899 default:
4900 assert(0 && "Unsupported architecture");
4901 }
4902
4903 ArgStringList CmdArgs;
4904
David Chisnall272a0712012-02-29 15:06:12 +00004905 // Demangle C++ names in errors
4906 CmdArgs.push_back("-C");
4907
David Chisnallf571cde2012-02-15 13:39:01 +00004908 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4909 (!Args.hasArg(options::OPT_shared))) {
4910 CmdArgs.push_back("-e");
4911 CmdArgs.push_back("_start");
4912 }
4913
4914 if (Args.hasArg(options::OPT_static)) {
4915 CmdArgs.push_back("-Bstatic");
4916 CmdArgs.push_back("-dn");
4917 } else {
4918 CmdArgs.push_back("-Bdynamic");
4919 if (Args.hasArg(options::OPT_shared)) {
4920 CmdArgs.push_back("-shared");
4921 } else {
4922 CmdArgs.push_back("--dynamic-linker");
4923 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
4924 }
4925 }
4926
4927 if (Output.isFilename()) {
4928 CmdArgs.push_back("-o");
4929 CmdArgs.push_back(Output.getFilename());
4930 } else {
4931 assert(Output.isNothing() && "Invalid output.");
4932 }
4933
4934 if (!Args.hasArg(options::OPT_nostdlib) &&
4935 !Args.hasArg(options::OPT_nostartfiles)) {
4936 if (!Args.hasArg(options::OPT_shared)) {
4937 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
4938 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004939 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004940 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4941 } else {
4942 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00004943 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4944 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004945 }
David Chisnallddc4c9d2012-03-13 14:14:54 +00004946 if (getToolChain().getDriver().CCCIsCXX)
4947 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004948 }
4949
4950 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
4951
4952 Args.AddAllArgs(CmdArgs, options::OPT_L);
4953 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4954 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00004955 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00004956
4957 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4958
4959 if (!Args.hasArg(options::OPT_nostdlib) &&
4960 !Args.hasArg(options::OPT_nodefaultlibs)) {
David Chisnall3d127c72012-04-10 11:49:50 +00004961 if (getToolChain().getDriver().CCCIsCXX)
4962 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00004963 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004964 if (!Args.hasArg(options::OPT_shared)) {
4965 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00004966 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00004967 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00004968 }
David Chisnallf571cde2012-02-15 13:39:01 +00004969 }
4970
4971 if (!Args.hasArg(options::OPT_nostdlib) &&
4972 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00004973 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004974 }
David Chisnall96de9932012-02-16 16:00:47 +00004975 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00004976
4977 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4978
4979 const char *Exec =
4980 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4981 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4982}
4983
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004984void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004985 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004986 const InputInfoList &Inputs,
4987 const ArgList &Args,
4988 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004989 ArgStringList CmdArgs;
4990
4991 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4992 options::OPT_Xassembler);
4993
4994 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00004995 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00004996
4997 for (InputInfoList::const_iterator
4998 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4999 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005000 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005001 }
5002
5003 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005004 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005005 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005006}
5007
5008void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005009 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005010 const InputInfoList &Inputs,
5011 const ArgList &Args,
5012 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005013 ArgStringList CmdArgs;
5014
5015 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005016 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005017 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005018 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005019 }
5020
5021 if (Args.hasArg(options::OPT_static)) {
5022 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005023 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005024 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005025// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005026 CmdArgs.push_back("-Bdynamic");
5027 if (Args.hasArg(options::OPT_shared)) {
5028 CmdArgs.push_back("-shared");
5029 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005030 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005031 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5032 }
5033 }
5034
Daniel Dunbarb440f562010-08-02 02:38:21 +00005035 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005036 CmdArgs.push_back("-o");
5037 CmdArgs.push_back(Output.getFilename());
5038 } else {
5039 assert(Output.isNothing() && "Invalid output.");
5040 }
5041
5042 if (!Args.hasArg(options::OPT_nostdlib) &&
5043 !Args.hasArg(options::OPT_nostartfiles)) {
5044 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005045 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005046 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005047 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005048 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005049 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005050 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005051 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005052 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005053 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005054 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005055 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005056 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005057 }
5058
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005059 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5060 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005061 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005062
5063 Args.AddAllArgs(CmdArgs, options::OPT_L);
5064 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5065 Args.AddAllArgs(CmdArgs, options::OPT_e);
5066
Daniel Dunbar54423b22010-09-17 00:24:54 +00005067 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005068
5069 if (!Args.hasArg(options::OPT_nostdlib) &&
5070 !Args.hasArg(options::OPT_nodefaultlibs)) {
5071 // FIXME: For some reason GCC passes -lgcc before adding
5072 // the default system libraries. Just mimic this for now.
5073 CmdArgs.push_back("-lgcc");
5074
5075 if (Args.hasArg(options::OPT_pthread))
5076 CmdArgs.push_back("-pthread");
5077 if (!Args.hasArg(options::OPT_shared))
5078 CmdArgs.push_back("-lc");
5079 CmdArgs.push_back("-lgcc");
5080 }
5081
5082 if (!Args.hasArg(options::OPT_nostdlib) &&
5083 !Args.hasArg(options::OPT_nostartfiles)) {
5084 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005085 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005086 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005087 }
5088
Bill Wendling08760582011-06-27 19:15:03 +00005089 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005090
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005091 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005092 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005093 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005094}
5095
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005096void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005097 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005098 const InputInfoList &Inputs,
5099 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005100 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005101 ArgStringList CmdArgs;
5102
5103 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5104 options::OPT_Xassembler);
5105
5106 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005107 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005108
5109 for (InputInfoList::const_iterator
5110 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5111 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005112 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005113 }
5114
5115 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005116 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005117 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005118}
5119
5120void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005121 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005122 const InputInfoList &Inputs,
5123 const ArgList &Args,
5124 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005125 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005126 ArgStringList CmdArgs;
5127
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005128 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005129 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005130 CmdArgs.push_back("-e");
5131 CmdArgs.push_back("__start");
5132 }
5133
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005134 if (Args.hasArg(options::OPT_static)) {
5135 CmdArgs.push_back("-Bstatic");
5136 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005137 if (Args.hasArg(options::OPT_rdynamic))
5138 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005139 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005140 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005141 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005142 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005143 } else {
5144 CmdArgs.push_back("-dynamic-linker");
5145 CmdArgs.push_back("/usr/libexec/ld.so");
5146 }
5147 }
5148
Daniel Dunbarb440f562010-08-02 02:38:21 +00005149 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005150 CmdArgs.push_back("-o");
5151 CmdArgs.push_back(Output.getFilename());
5152 } else {
5153 assert(Output.isNothing() && "Invalid output.");
5154 }
5155
5156 if (!Args.hasArg(options::OPT_nostdlib) &&
5157 !Args.hasArg(options::OPT_nostartfiles)) {
5158 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00005159 if (Args.hasArg(options::OPT_pg))
5160 CmdArgs.push_back(Args.MakeArgString(
5161 getToolChain().GetFilePath("gcrt0.o")));
5162 else
5163 CmdArgs.push_back(Args.MakeArgString(
5164 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005165 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005166 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005167 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005168 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005169 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005170 }
5171 }
5172
Edward O'Callaghan5c521462009-10-28 15:13:08 +00005173 std::string Triple = getToolChain().getTripleString();
5174 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005175 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005176 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005177 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005178
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005179 Args.AddAllArgs(CmdArgs, options::OPT_L);
5180 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5181 Args.AddAllArgs(CmdArgs, options::OPT_e);
5182
Daniel Dunbar54423b22010-09-17 00:24:54 +00005183 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005184
5185 if (!Args.hasArg(options::OPT_nostdlib) &&
5186 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005187 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005188 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00005189 if (Args.hasArg(options::OPT_pg))
5190 CmdArgs.push_back("-lm_p");
5191 else
5192 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005193 }
5194
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005195 // FIXME: For some reason GCC passes -lgcc before adding
5196 // the default system libraries. Just mimic this for now.
5197 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005198
Eric Christopher17674ec2012-09-13 06:32:34 +00005199 if (Args.hasArg(options::OPT_pthread)) {
5200 if (!Args.hasArg(options::OPT_shared) &&
5201 Args.hasArg(options::OPT_pg))
5202 CmdArgs.push_back("-lpthread_p");
5203 else
5204 CmdArgs.push_back("-lpthread");
5205 }
5206
Chandler Carruth45661652011-12-17 22:32:42 +00005207 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00005208 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00005209 CmdArgs.push_back("-lc_p");
5210 else
5211 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00005212 }
Eric Christopher17674ec2012-09-13 06:32:34 +00005213
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005214 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005215 }
5216
5217 if (!Args.hasArg(options::OPT_nostdlib) &&
5218 !Args.hasArg(options::OPT_nostartfiles)) {
5219 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005220 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005221 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005222 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005223 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005224 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005225 }
5226
5227 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005228 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005229 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005230}
Ed Schoutene33194b2009-04-02 19:13:12 +00005231
Eli Friedman9fa28852012-08-08 23:57:20 +00005232void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5233 const InputInfo &Output,
5234 const InputInfoList &Inputs,
5235 const ArgList &Args,
5236 const char *LinkingOutput) const {
5237 ArgStringList CmdArgs;
5238
5239 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5240 options::OPT_Xassembler);
5241
5242 CmdArgs.push_back("-o");
5243 CmdArgs.push_back(Output.getFilename());
5244
5245 for (InputInfoList::const_iterator
5246 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5247 const InputInfo &II = *it;
5248 CmdArgs.push_back(II.getFilename());
5249 }
5250
5251 const char *Exec =
5252 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5253 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5254}
5255
5256void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5257 const InputInfo &Output,
5258 const InputInfoList &Inputs,
5259 const ArgList &Args,
5260 const char *LinkingOutput) const {
5261 const Driver &D = getToolChain().getDriver();
5262 ArgStringList CmdArgs;
5263
5264 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5265 (!Args.hasArg(options::OPT_shared))) {
5266 CmdArgs.push_back("-e");
5267 CmdArgs.push_back("__start");
5268 }
5269
5270 if (Args.hasArg(options::OPT_static)) {
5271 CmdArgs.push_back("-Bstatic");
5272 } else {
5273 if (Args.hasArg(options::OPT_rdynamic))
5274 CmdArgs.push_back("-export-dynamic");
5275 CmdArgs.push_back("--eh-frame-hdr");
5276 CmdArgs.push_back("-Bdynamic");
5277 if (Args.hasArg(options::OPT_shared)) {
5278 CmdArgs.push_back("-shared");
5279 } else {
5280 CmdArgs.push_back("-dynamic-linker");
5281 CmdArgs.push_back("/usr/libexec/ld.so");
5282 }
5283 }
5284
5285 if (Output.isFilename()) {
5286 CmdArgs.push_back("-o");
5287 CmdArgs.push_back(Output.getFilename());
5288 } else {
5289 assert(Output.isNothing() && "Invalid output.");
5290 }
5291
5292 if (!Args.hasArg(options::OPT_nostdlib) &&
5293 !Args.hasArg(options::OPT_nostartfiles)) {
5294 if (!Args.hasArg(options::OPT_shared)) {
5295 if (Args.hasArg(options::OPT_pg))
5296 CmdArgs.push_back(Args.MakeArgString(
5297 getToolChain().GetFilePath("gcrt0.o")));
5298 else
5299 CmdArgs.push_back(Args.MakeArgString(
5300 getToolChain().GetFilePath("crt0.o")));
5301 CmdArgs.push_back(Args.MakeArgString(
5302 getToolChain().GetFilePath("crtbegin.o")));
5303 } else {
5304 CmdArgs.push_back(Args.MakeArgString(
5305 getToolChain().GetFilePath("crtbeginS.o")));
5306 }
5307 }
5308
5309 Args.AddAllArgs(CmdArgs, options::OPT_L);
5310 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5311 Args.AddAllArgs(CmdArgs, options::OPT_e);
5312
5313 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5314
5315 if (!Args.hasArg(options::OPT_nostdlib) &&
5316 !Args.hasArg(options::OPT_nodefaultlibs)) {
5317 if (D.CCCIsCXX) {
5318 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5319 if (Args.hasArg(options::OPT_pg))
5320 CmdArgs.push_back("-lm_p");
5321 else
5322 CmdArgs.push_back("-lm");
5323 }
5324
Rafael Espindola1ad26f02012-10-23 17:07:31 +00005325 if (Args.hasArg(options::OPT_pthread)) {
5326 if (!Args.hasArg(options::OPT_shared) &&
5327 Args.hasArg(options::OPT_pg))
5328 CmdArgs.push_back("-lpthread_p");
5329 else
5330 CmdArgs.push_back("-lpthread");
5331 }
5332
Eli Friedman9fa28852012-08-08 23:57:20 +00005333 if (!Args.hasArg(options::OPT_shared)) {
5334 if (Args.hasArg(options::OPT_pg))
5335 CmdArgs.push_back("-lc_p");
5336 else
5337 CmdArgs.push_back("-lc");
5338 }
5339
5340 std::string myarch = "-lclang_rt.";
5341 const llvm::Triple &T = getToolChain().getTriple();
5342 llvm::Triple::ArchType Arch = T.getArch();
5343 switch (Arch) {
5344 case llvm::Triple::arm:
5345 myarch += ("arm");
5346 break;
5347 case llvm::Triple::x86:
5348 myarch += ("i386");
5349 break;
5350 case llvm::Triple::x86_64:
5351 myarch += ("amd64");
5352 break;
5353 default:
5354 assert(0 && "Unsupported architecture");
5355 }
5356 CmdArgs.push_back(Args.MakeArgString(myarch));
5357 }
5358
5359 if (!Args.hasArg(options::OPT_nostdlib) &&
5360 !Args.hasArg(options::OPT_nostartfiles)) {
5361 if (!Args.hasArg(options::OPT_shared))
5362 CmdArgs.push_back(Args.MakeArgString(
5363 getToolChain().GetFilePath("crtend.o")));
5364 else
5365 CmdArgs.push_back(Args.MakeArgString(
5366 getToolChain().GetFilePath("crtendS.o")));
5367 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005368
5369 const char *Exec =
5370 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5371 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00005372}
5373
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005374void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005375 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005376 const InputInfoList &Inputs,
5377 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005378 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005379 ArgStringList CmdArgs;
5380
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005381 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5382 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005383 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005384 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005385 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00005386 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005387 else if (getToolChain().getArch() == llvm::Triple::mips ||
5388 getToolChain().getArch() == llvm::Triple::mipsel ||
5389 getToolChain().getArch() == llvm::Triple::mips64 ||
5390 getToolChain().getArch() == llvm::Triple::mips64el) {
5391 StringRef CPUName;
5392 StringRef ABIName;
5393 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005394
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005395 CmdArgs.push_back("-march");
5396 CmdArgs.push_back(CPUName.data());
5397
5398 // Convert ABI name to the GNU tools acceptable variant.
5399 if (ABIName == "o32")
5400 ABIName = "32";
5401 else if (ABIName == "n64")
5402 ABIName = "64";
5403
5404 CmdArgs.push_back("-mabi");
5405 CmdArgs.push_back(ABIName.data());
5406
5407 if (getToolChain().getArch() == llvm::Triple::mips ||
5408 getToolChain().getArch() == llvm::Triple::mips64)
5409 CmdArgs.push_back("-EB");
5410 else
5411 CmdArgs.push_back("-EL");
5412
5413 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5414 options::OPT_fpic, options::OPT_fno_pic,
5415 options::OPT_fPIE, options::OPT_fno_PIE,
5416 options::OPT_fpie, options::OPT_fno_pie);
5417 if (LastPICArg &&
5418 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5419 LastPICArg->getOption().matches(options::OPT_fpic) ||
5420 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5421 LastPICArg->getOption().matches(options::OPT_fpie))) {
5422 CmdArgs.push_back("-KPIC");
5423 }
5424 }
Eric Christopher0b26a612010-03-02 02:41:08 +00005425
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005426 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5427 options::OPT_Xassembler);
5428
5429 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005430 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005431
5432 for (InputInfoList::const_iterator
5433 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5434 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005435 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005436 }
5437
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005438 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005439 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005440 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005441}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005442
5443void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005444 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005445 const InputInfoList &Inputs,
5446 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005447 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00005448 const toolchains::FreeBSD& ToolChain =
5449 static_cast<const toolchains::FreeBSD&>(getToolChain());
5450 const Driver &D = ToolChain.getDriver();
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005451 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00005452
5453 // Silence warning for "clang -g foo.o -o foo"
5454 Args.ClaimAllArgs(options::OPT_g_Group);
5455 // and "clang -emit-llvm foo.o -o foo"
5456 Args.ClaimAllArgs(options::OPT_emit_llvm);
5457 // and for "clang -w foo.o -o foo". Other warning options are already
5458 // handled somewhere else.
5459 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005460
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005461 if (!D.SysRoot.empty())
5462 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5463
Roman Divackyafe2f232012-08-28 15:09:03 +00005464 if (Args.hasArg(options::OPT_pie))
5465 CmdArgs.push_back("-pie");
5466
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005467 if (Args.hasArg(options::OPT_static)) {
5468 CmdArgs.push_back("-Bstatic");
5469 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005470 if (Args.hasArg(options::OPT_rdynamic))
5471 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005472 CmdArgs.push_back("--eh-frame-hdr");
5473 if (Args.hasArg(options::OPT_shared)) {
5474 CmdArgs.push_back("-Bshareable");
5475 } else {
5476 CmdArgs.push_back("-dynamic-linker");
5477 CmdArgs.push_back("/libexec/ld-elf.so.1");
5478 }
Roman Divackyafe2f232012-08-28 15:09:03 +00005479 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5480 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00005481 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5482 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5483 CmdArgs.push_back("--hash-style=both");
5484 }
5485 }
5486 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005487 }
5488
5489 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5490 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005491 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005492 CmdArgs.push_back("-m");
5493 CmdArgs.push_back("elf_i386_fbsd");
5494 }
5495
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005496 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00005497 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00005498 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00005499 }
5500
Daniel Dunbarb440f562010-08-02 02:38:21 +00005501 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005502 CmdArgs.push_back("-o");
5503 CmdArgs.push_back(Output.getFilename());
5504 } else {
5505 assert(Output.isNothing() && "Invalid output.");
5506 }
5507
5508 if (!Args.hasArg(options::OPT_nostdlib) &&
5509 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00005510 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005511 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00005512 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00005513 crt1 = "gcrt1.o";
5514 else if (Args.hasArg(options::OPT_pie))
5515 crt1 = "Scrt1.o";
5516 else
5517 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005518 }
Roman Divackyafe2f232012-08-28 15:09:03 +00005519 if (crt1)
5520 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5521
5522 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5523
5524 const char *crtbegin = NULL;
5525 if (Args.hasArg(options::OPT_static))
5526 crtbegin = "crtbeginT.o";
5527 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5528 crtbegin = "crtbeginS.o";
5529 else
5530 crtbegin = "crtbegin.o";
5531
5532 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005533 }
5534
5535 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00005536 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00005537 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5538 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005539 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005540 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5541 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00005542 Args.AddAllArgs(CmdArgs, options::OPT_s);
5543 Args.AddAllArgs(CmdArgs, options::OPT_t);
5544 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5545 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005546
Roman Divackyafe2f232012-08-28 15:09:03 +00005547 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005548
5549 if (!Args.hasArg(options::OPT_nostdlib) &&
5550 !Args.hasArg(options::OPT_nodefaultlibs)) {
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00005551 if (D.CCCIsCXX) {
Roman Divackyafe2f232012-08-28 15:09:03 +00005552 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00005553 if (Args.hasArg(options::OPT_pg))
5554 CmdArgs.push_back("-lm_p");
5555 else
5556 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00005557 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005558 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5559 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00005560 if (Args.hasArg(options::OPT_pg))
5561 CmdArgs.push_back("-lgcc_p");
5562 else
5563 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005564 if (Args.hasArg(options::OPT_static)) {
5565 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005566 } else if (Args.hasArg(options::OPT_pg)) {
5567 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005568 } else {
5569 CmdArgs.push_back("--as-needed");
5570 CmdArgs.push_back("-lgcc_s");
5571 CmdArgs.push_back("--no-as-needed");
5572 }
5573
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005574 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00005575 if (Args.hasArg(options::OPT_pg))
5576 CmdArgs.push_back("-lpthread_p");
5577 else
5578 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00005579 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005580
Roman Divacky66f22762011-02-10 16:59:40 +00005581 if (Args.hasArg(options::OPT_pg)) {
5582 if (Args.hasArg(options::OPT_shared))
5583 CmdArgs.push_back("-lc");
5584 else
5585 CmdArgs.push_back("-lc_p");
5586 CmdArgs.push_back("-lgcc_p");
5587 } else {
5588 CmdArgs.push_back("-lc");
5589 CmdArgs.push_back("-lgcc");
5590 }
5591
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005592 if (Args.hasArg(options::OPT_static)) {
5593 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00005594 } else if (Args.hasArg(options::OPT_pg)) {
5595 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005596 } else {
5597 CmdArgs.push_back("--as-needed");
5598 CmdArgs.push_back("-lgcc_s");
5599 CmdArgs.push_back("--no-as-needed");
5600 }
5601 }
5602
5603 if (!Args.hasArg(options::OPT_nostdlib) &&
5604 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackya3c50242012-09-07 13:36:21 +00005605 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Roman Divackyafe2f232012-08-28 15:09:03 +00005606 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00005607 else
5608 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00005609 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005610 }
5611
Roman Divackyafe2f232012-08-28 15:09:03 +00005612 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005613
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005614 const char *Exec =
Roman Divackyafe2f232012-08-28 15:09:03 +00005615 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005616 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005617}
Daniel Dunbarcc912342009-05-02 18:28:39 +00005618
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005619void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5620 const InputInfo &Output,
5621 const InputInfoList &Inputs,
5622 const ArgList &Args,
5623 const char *LinkingOutput) const {
5624 ArgStringList CmdArgs;
5625
5626 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5627 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005628 if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005629 CmdArgs.push_back("--32");
5630
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005631 // Set byte order explicitly
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005632 if (getToolChain().getArch() == llvm::Triple::mips)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005633 CmdArgs.push_back("-EB");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005634 else if (getToolChain().getArch() == llvm::Triple::mipsel)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005635 CmdArgs.push_back("-EL");
5636
5637 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5638 options::OPT_Xassembler);
5639
5640 CmdArgs.push_back("-o");
5641 CmdArgs.push_back(Output.getFilename());
5642
5643 for (InputInfoList::const_iterator
5644 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5645 const InputInfo &II = *it;
5646 CmdArgs.push_back(II.getFilename());
5647 }
5648
David Chisnallddbd68f2011-09-27 22:03:18 +00005649 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005650 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5651}
5652
5653void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5654 const InputInfo &Output,
5655 const InputInfoList &Inputs,
5656 const ArgList &Args,
5657 const char *LinkingOutput) const {
5658 const Driver &D = getToolChain().getDriver();
5659 ArgStringList CmdArgs;
5660
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005661 if (!D.SysRoot.empty())
5662 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5663
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005664 if (Args.hasArg(options::OPT_static)) {
5665 CmdArgs.push_back("-Bstatic");
5666 } else {
5667 if (Args.hasArg(options::OPT_rdynamic))
5668 CmdArgs.push_back("-export-dynamic");
5669 CmdArgs.push_back("--eh-frame-hdr");
5670 if (Args.hasArg(options::OPT_shared)) {
5671 CmdArgs.push_back("-Bshareable");
5672 } else {
5673 CmdArgs.push_back("-dynamic-linker");
5674 CmdArgs.push_back("/libexec/ld.elf_so");
5675 }
5676 }
5677
5678 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5679 // instruct ld in the base system to link 32-bit code.
Joerg Sonnenbergerd64c60e2012-01-26 22:27:52 +00005680 if (getToolChain().getArch() == llvm::Triple::x86) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005681 CmdArgs.push_back("-m");
5682 CmdArgs.push_back("elf_i386");
5683 }
5684
5685 if (Output.isFilename()) {
5686 CmdArgs.push_back("-o");
5687 CmdArgs.push_back(Output.getFilename());
5688 } else {
5689 assert(Output.isNothing() && "Invalid output.");
5690 }
5691
5692 if (!Args.hasArg(options::OPT_nostdlib) &&
5693 !Args.hasArg(options::OPT_nostartfiles)) {
5694 if (!Args.hasArg(options::OPT_shared)) {
5695 CmdArgs.push_back(Args.MakeArgString(
5696 getToolChain().GetFilePath("crt0.o")));
5697 CmdArgs.push_back(Args.MakeArgString(
5698 getToolChain().GetFilePath("crti.o")));
5699 CmdArgs.push_back(Args.MakeArgString(
5700 getToolChain().GetFilePath("crtbegin.o")));
5701 } else {
5702 CmdArgs.push_back(Args.MakeArgString(
5703 getToolChain().GetFilePath("crti.o")));
5704 CmdArgs.push_back(Args.MakeArgString(
5705 getToolChain().GetFilePath("crtbeginS.o")));
5706 }
5707 }
5708
5709 Args.AddAllArgs(CmdArgs, options::OPT_L);
5710 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5711 Args.AddAllArgs(CmdArgs, options::OPT_e);
5712 Args.AddAllArgs(CmdArgs, options::OPT_s);
5713 Args.AddAllArgs(CmdArgs, options::OPT_t);
5714 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5715 Args.AddAllArgs(CmdArgs, options::OPT_r);
5716
5717 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5718
5719 if (!Args.hasArg(options::OPT_nostdlib) &&
5720 !Args.hasArg(options::OPT_nodefaultlibs)) {
5721 if (D.CCCIsCXX) {
5722 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5723 CmdArgs.push_back("-lm");
5724 }
5725 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5726 // the default system libraries. Just mimic this for now.
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005727 if (Args.hasArg(options::OPT_static)) {
5728 CmdArgs.push_back("-lgcc_eh");
5729 } else {
5730 CmdArgs.push_back("--as-needed");
5731 CmdArgs.push_back("-lgcc_s");
5732 CmdArgs.push_back("--no-as-needed");
5733 }
Joerg Sonnenberger87717772011-06-07 23:39:17 +00005734 CmdArgs.push_back("-lgcc");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005735
5736 if (Args.hasArg(options::OPT_pthread))
5737 CmdArgs.push_back("-lpthread");
5738 CmdArgs.push_back("-lc");
5739
5740 CmdArgs.push_back("-lgcc");
5741 if (Args.hasArg(options::OPT_static)) {
5742 CmdArgs.push_back("-lgcc_eh");
5743 } else {
5744 CmdArgs.push_back("--as-needed");
5745 CmdArgs.push_back("-lgcc_s");
5746 CmdArgs.push_back("--no-as-needed");
5747 }
5748 }
5749
5750 if (!Args.hasArg(options::OPT_nostdlib) &&
5751 !Args.hasArg(options::OPT_nostartfiles)) {
5752 if (!Args.hasArg(options::OPT_shared))
5753 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5754 "crtend.o")));
5755 else
5756 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5757 "crtendS.o")));
5758 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5759 "crtn.o")));
5760 }
5761
Bill Wendling08760582011-06-27 19:15:03 +00005762 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005763
David Chisnallddbd68f2011-09-27 22:03:18 +00005764 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00005765 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5766}
5767
Rafael Espindola92b00932010-08-10 00:25:48 +00005768void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5769 const InputInfo &Output,
5770 const InputInfoList &Inputs,
5771 const ArgList &Args,
5772 const char *LinkingOutput) const {
5773 ArgStringList CmdArgs;
5774
5775 // Add --32/--64 to make sure we get the format we want.
5776 // This is incomplete
5777 if (getToolChain().getArch() == llvm::Triple::x86) {
5778 CmdArgs.push_back("--32");
5779 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5780 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00005781 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5782 CmdArgs.push_back("-a32");
5783 CmdArgs.push_back("-mppc");
5784 CmdArgs.push_back("-many");
5785 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5786 CmdArgs.push_back("-a64");
5787 CmdArgs.push_back("-mppc64");
5788 CmdArgs.push_back("-many");
Rafael Espindola92b00932010-08-10 00:25:48 +00005789 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005790 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00005791 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5792 CmdArgs.push_back("-mfpu=neon");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00005793
5794 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5795 getToolChain().getTriple());
5796 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00005797
5798 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5799 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5800 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005801 } else if (getToolChain().getArch() == llvm::Triple::mips ||
5802 getToolChain().getArch() == llvm::Triple::mipsel ||
5803 getToolChain().getArch() == llvm::Triple::mips64 ||
5804 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005805 StringRef CPUName;
5806 StringRef ABIName;
5807 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00005808
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00005809 CmdArgs.push_back("-march");
5810 CmdArgs.push_back(CPUName.data());
5811
5812 // Convert ABI name to the GNU tools acceptable variant.
5813 if (ABIName == "o32")
5814 ABIName = "32";
5815 else if (ABIName == "n64")
5816 ABIName = "64";
5817
5818 CmdArgs.push_back("-mabi");
5819 CmdArgs.push_back(ABIName.data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00005820
5821 if (getToolChain().getArch() == llvm::Triple::mips ||
5822 getToolChain().getArch() == llvm::Triple::mips64)
5823 CmdArgs.push_back("-EB");
5824 else
5825 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00005826
5827 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5828 options::OPT_fpic, options::OPT_fno_pic,
5829 options::OPT_fPIE, options::OPT_fno_PIE,
5830 options::OPT_fpie, options::OPT_fno_pie);
5831 if (LastPICArg &&
5832 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5833 LastPICArg->getOption().matches(options::OPT_fpic) ||
5834 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5835 LastPICArg->getOption().matches(options::OPT_fpie))) {
5836 CmdArgs.push_back("-KPIC");
5837 }
Rafael Espindola92b00932010-08-10 00:25:48 +00005838 }
5839
5840 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5841 options::OPT_Xassembler);
5842
5843 CmdArgs.push_back("-o");
5844 CmdArgs.push_back(Output.getFilename());
5845
5846 for (InputInfoList::const_iterator
5847 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5848 const InputInfo &II = *it;
5849 CmdArgs.push_back(II.getFilename());
5850 }
5851
5852 const char *Exec =
5853 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5854 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5855}
5856
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005857static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5858 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00005859 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005860 bool StaticLibgcc = isAndroid || Args.hasArg(options::OPT_static) ||
Rafael Espindolacc354322011-10-17 21:39:04 +00005861 Args.hasArg(options::OPT_static_libgcc);
5862 if (!D.CCCIsCXX)
5863 CmdArgs.push_back("-lgcc");
5864
5865 if (StaticLibgcc) {
5866 if (D.CCCIsCXX)
5867 CmdArgs.push_back("-lgcc");
5868 } else {
5869 if (!D.CCCIsCXX)
5870 CmdArgs.push_back("--as-needed");
5871 CmdArgs.push_back("-lgcc_s");
5872 if (!D.CCCIsCXX)
5873 CmdArgs.push_back("--no-as-needed");
5874 }
5875
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005876 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00005877 CmdArgs.push_back("-lgcc_eh");
5878 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
5879 CmdArgs.push_back("-lgcc");
5880}
5881
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005882static bool hasMipsN32ABIArg(const ArgList &Args) {
5883 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
Richard Smithbd55daf2012-11-01 04:30:05 +00005884 return A && (A->getValue() == StringRef("n32"));
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005885}
5886
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005887void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
5888 const InputInfo &Output,
5889 const InputInfoList &Inputs,
5890 const ArgList &Args,
5891 const char *LinkingOutput) const {
5892 const toolchains::Linux& ToolChain =
5893 static_cast<const toolchains::Linux&>(getToolChain());
5894 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00005895 const bool isAndroid =
5896 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005897
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005898 ArgStringList CmdArgs;
5899
Rafael Espindolad1002f62010-11-15 18:28:16 +00005900 // Silence warning for "clang -g foo.o -o foo"
5901 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005902 // and "clang -emit-llvm foo.o -o foo"
5903 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00005904 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00005905 // handled somewhere else.
5906 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00005907
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00005908 if (!D.SysRoot.empty())
5909 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005910
Rafael Espindolad47ac232010-11-17 22:26:15 +00005911 if (Args.hasArg(options::OPT_pie))
5912 CmdArgs.push_back("-pie");
5913
Rafael Espindola1c76c592010-11-07 22:57:16 +00005914 if (Args.hasArg(options::OPT_rdynamic))
5915 CmdArgs.push_back("-export-dynamic");
5916
Rafael Espindola34d77dc2010-11-11 19:34:42 +00005917 if (Args.hasArg(options::OPT_s))
5918 CmdArgs.push_back("-s");
5919
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005920 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
5921 e = ToolChain.ExtraOpts.end();
5922 i != e; ++i)
5923 CmdArgs.push_back(i->c_str());
5924
5925 if (!Args.hasArg(options::OPT_static)) {
5926 CmdArgs.push_back("--eh-frame-hdr");
5927 }
5928
5929 CmdArgs.push_back("-m");
5930 if (ToolChain.getArch() == llvm::Triple::x86)
5931 CmdArgs.push_back("elf_i386");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005932 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00005933 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005934 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005935 else if (ToolChain.getArch() == llvm::Triple::ppc)
5936 CmdArgs.push_back("elf32ppclinux");
5937 else if (ToolChain.getArch() == llvm::Triple::ppc64)
5938 CmdArgs.push_back("elf64ppc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005939 else if (ToolChain.getArch() == llvm::Triple::mips)
5940 CmdArgs.push_back("elf32btsmip");
5941 else if (ToolChain.getArch() == llvm::Triple::mipsel)
5942 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005943 else if (ToolChain.getArch() == llvm::Triple::mips64) {
5944 if (hasMipsN32ABIArg(Args))
5945 CmdArgs.push_back("elf32btsmipn32");
5946 else
5947 CmdArgs.push_back("elf64btsmip");
5948 }
5949 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
5950 if (hasMipsN32ABIArg(Args))
5951 CmdArgs.push_back("elf32ltsmipn32");
5952 else
5953 CmdArgs.push_back("elf64ltsmip");
5954 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005955 else
5956 CmdArgs.push_back("elf_x86_64");
5957
5958 if (Args.hasArg(options::OPT_static)) {
Douglas Gregord9bb1522011-03-06 19:11:49 +00005959 if (ToolChain.getArch() == llvm::Triple::arm
5960 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005961 CmdArgs.push_back("-Bstatic");
5962 else
5963 CmdArgs.push_back("-static");
5964 } else if (Args.hasArg(options::OPT_shared)) {
5965 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00005966 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005967 CmdArgs.push_back("-Bsymbolic");
5968 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005969 }
5970
5971 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00005972 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005973 (!Args.hasArg(options::OPT_static) &&
5974 !Args.hasArg(options::OPT_shared))) {
5975 CmdArgs.push_back("-dynamic-linker");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00005976 if (isAndroid)
5977 CmdArgs.push_back("/system/bin/linker");
5978 else if (ToolChain.getArch() == llvm::Triple::x86)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00005979 CmdArgs.push_back("/lib/ld-linux.so.2");
Douglas Gregord9bb1522011-03-06 19:11:49 +00005980 else if (ToolChain.getArch() == llvm::Triple::arm ||
Jiangning Liueabbf922012-07-30 11:05:56 +00005981 ToolChain.getArch() == llvm::Triple::thumb) {
5982 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
5983 CmdArgs.push_back("/lib/ld-linux-armhf.so.3");
5984 else
5985 CmdArgs.push_back("/lib/ld-linux.so.3");
5986 }
Eli Friedman27b8c4f2011-11-08 19:43:37 +00005987 else if (ToolChain.getArch() == llvm::Triple::mips ||
5988 ToolChain.getArch() == llvm::Triple::mipsel)
5989 CmdArgs.push_back("/lib/ld.so.1");
Simon Atanasyan1e1e2e22012-04-06 20:14:27 +00005990 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00005991 ToolChain.getArch() == llvm::Triple::mips64el) {
5992 if (hasMipsN32ABIArg(Args))
5993 CmdArgs.push_back("/lib32/ld.so.1");
5994 else
5995 CmdArgs.push_back("/lib64/ld.so.1");
5996 }
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005997 else if (ToolChain.getArch() == llvm::Triple::ppc)
Chris Lattner20b90d02011-04-11 21:15:37 +00005998 CmdArgs.push_back("/lib/ld.so.1");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00005999 else if (ToolChain.getArch() == llvm::Triple::ppc64)
Chris Lattner20b90d02011-04-11 21:15:37 +00006000 CmdArgs.push_back("/lib64/ld64.so.1");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006001 else
6002 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
6003 }
6004
6005 CmdArgs.push_back("-o");
6006 CmdArgs.push_back(Output.getFilename());
6007
Rafael Espindola81937ec2010-12-01 01:52:43 +00006008 if (!Args.hasArg(options::OPT_nostdlib) &&
6009 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006010 if (!isAndroid) {
6011 const char *crt1 = NULL;
6012 if (!Args.hasArg(options::OPT_shared)){
6013 if (Args.hasArg(options::OPT_pie))
6014 crt1 = "Scrt1.o";
6015 else
6016 crt1 = "crt1.o";
6017 }
6018 if (crt1)
6019 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006020
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006021 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6022 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006023
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006024 const char *crtbegin;
6025 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006026 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006027 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006028 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006029 else if (Args.hasArg(options::OPT_pie))
6030 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006031 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006032 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006033 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00006034
6035 // Add crtfastmath.o if available and fast math is enabled.
6036 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006037 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006038
6039 Args.AddAllArgs(CmdArgs, options::OPT_L);
6040
6041 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6042
Roman Divackyee8188a2011-03-01 17:53:14 +00006043 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6044 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006045 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006046
Rafael Espindola9446d762012-04-09 23:53:34 +00006047 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6048 // as gold requires -plugin to come before any -plugin-opt that -Wl might
6049 // forward.
6050 if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) {
6051 CmdArgs.push_back("-plugin");
6052 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6053 CmdArgs.push_back(Args.MakeArgString(Plugin));
6054 }
6055
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00006056 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6057 CmdArgs.push_back("--no-demangle");
6058
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006059 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6060
Alexey Samsonov627b10f2012-11-06 15:09:03 +00006061 SanitizerArgs Sanitize(D, Args);
Richard Smith52be6192012-11-05 22:04:41 +00006062
Richard Smith4d3110a2012-10-25 02:14:12 +00006063 // Call this before we add the C++ ABI library.
Richard Smith52be6192012-11-05 22:04:41 +00006064 if (Sanitize.needsUbsanRt())
6065 addUbsanRTLinux(getToolChain(), Args, CmdArgs);
Richard Smith4d3110a2012-10-25 02:14:12 +00006066
Chandler Carruth94a32012012-05-14 18:31:18 +00006067 if (D.CCCIsCXX &&
6068 !Args.hasArg(options::OPT_nostdlib) &&
6069 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00006070 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6071 !Args.hasArg(options::OPT_static);
6072 if (OnlyLibstdcxxStatic)
6073 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006074 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00006075 if (OnlyLibstdcxxStatic)
6076 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006077 CmdArgs.push_back("-lm");
6078 }
6079
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00006080 // Call this before we add the C run-time.
Richard Smith52be6192012-11-05 22:04:41 +00006081 if (Sanitize.needsAsanRt())
6082 addAsanRTLinux(getToolChain(), Args, CmdArgs);
6083 if (Sanitize.needsTsanRt())
6084 addTsanRTLinux(getToolChain(), Args, CmdArgs);
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00006085
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006086 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00006087 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6088 if (Args.hasArg(options::OPT_static))
6089 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00006090
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006091 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006092
Chandler Carruth94a32012012-05-14 18:31:18 +00006093 if (Args.hasArg(options::OPT_pthread) ||
6094 Args.hasArg(options::OPT_pthreads))
6095 CmdArgs.push_back("-lpthread");
6096
6097 CmdArgs.push_back("-lc");
6098
6099 if (Args.hasArg(options::OPT_static))
6100 CmdArgs.push_back("--end-group");
6101 else
6102 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6103 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00006104
Rafael Espindola81937ec2010-12-01 01:52:43 +00006105 if (!Args.hasArg(options::OPT_nostartfiles)) {
6106 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006107 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006108 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006109 else if (Args.hasArg(options::OPT_pie))
6110 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00006111 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006112 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006113
Rafael Espindola81937ec2010-12-01 01:52:43 +00006114 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006115 if (!isAndroid)
6116 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00006117 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006118 }
6119
Bill Wendling08760582011-06-27 19:15:03 +00006120 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006121
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006122 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6123}
Rafael Espindola92b00932010-08-10 00:25:48 +00006124
Chris Lattner3e2ee142010-07-07 16:01:42 +00006125void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006126 const InputInfo &Output,
6127 const InputInfoList &Inputs,
6128 const ArgList &Args,
6129 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006130 ArgStringList CmdArgs;
6131
6132 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6133 options::OPT_Xassembler);
6134
6135 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006136 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006137
6138 for (InputInfoList::const_iterator
6139 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6140 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006141 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006142 }
6143
6144 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00006145 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006146 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006147}
6148
6149void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006150 const InputInfo &Output,
6151 const InputInfoList &Inputs,
6152 const ArgList &Args,
6153 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006154 const Driver &D = getToolChain().getDriver();
6155 ArgStringList CmdArgs;
6156
Daniel Dunbarb440f562010-08-02 02:38:21 +00006157 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006158 CmdArgs.push_back("-o");
6159 CmdArgs.push_back(Output.getFilename());
6160 } else {
6161 assert(Output.isNothing() && "Invalid output.");
6162 }
6163
6164 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00006165 !Args.hasArg(options::OPT_nostartfiles)) {
6166 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6167 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6168 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6169 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6170 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00006171
6172 Args.AddAllArgs(CmdArgs, options::OPT_L);
6173 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6174 Args.AddAllArgs(CmdArgs, options::OPT_e);
6175
Daniel Dunbar54423b22010-09-17 00:24:54 +00006176 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00006177
Eli Friedman83de5132011-12-08 23:54:21 +00006178 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6179
Chris Lattner3e2ee142010-07-07 16:01:42 +00006180 if (!Args.hasArg(options::OPT_nostdlib) &&
6181 !Args.hasArg(options::OPT_nodefaultlibs)) {
6182 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006183 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00006184 CmdArgs.push_back("-lm");
6185 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00006186 }
6187
6188 if (!Args.hasArg(options::OPT_nostdlib) &&
6189 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00006190 if (Args.hasArg(options::OPT_pthread))
6191 CmdArgs.push_back("-lpthread");
6192 CmdArgs.push_back("-lc");
6193 CmdArgs.push_back("-lCompilerRT-Generic");
6194 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6195 CmdArgs.push_back(
6196 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006197 }
6198
Eli Friedman83de5132011-12-08 23:54:21 +00006199 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006200 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006201}
6202
Daniel Dunbarcc912342009-05-02 18:28:39 +00006203/// DragonFly Tools
6204
6205// For now, DragonFly Assemble does just about the same as for
6206// FreeBSD, but this may change soon.
6207void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006208 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006209 const InputInfoList &Inputs,
6210 const ArgList &Args,
6211 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00006212 ArgStringList CmdArgs;
6213
6214 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6215 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006216 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00006217 CmdArgs.push_back("--32");
6218
6219 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6220 options::OPT_Xassembler);
6221
6222 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006223 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00006224
6225 for (InputInfoList::const_iterator
6226 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6227 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006228 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00006229 }
6230
6231 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006232 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006233 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006234}
6235
6236void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006237 const InputInfo &Output,
6238 const InputInfoList &Inputs,
6239 const ArgList &Args,
6240 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006241 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00006242 ArgStringList CmdArgs;
6243
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006244 if (!D.SysRoot.empty())
6245 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6246
Daniel Dunbarcc912342009-05-02 18:28:39 +00006247 if (Args.hasArg(options::OPT_static)) {
6248 CmdArgs.push_back("-Bstatic");
6249 } else {
6250 if (Args.hasArg(options::OPT_shared))
6251 CmdArgs.push_back("-Bshareable");
6252 else {
6253 CmdArgs.push_back("-dynamic-linker");
6254 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6255 }
6256 }
6257
6258 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6259 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006260 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00006261 CmdArgs.push_back("-m");
6262 CmdArgs.push_back("elf_i386");
6263 }
6264
Daniel Dunbarb440f562010-08-02 02:38:21 +00006265 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00006266 CmdArgs.push_back("-o");
6267 CmdArgs.push_back(Output.getFilename());
6268 } else {
6269 assert(Output.isNothing() && "Invalid output.");
6270 }
6271
6272 if (!Args.hasArg(options::OPT_nostdlib) &&
6273 !Args.hasArg(options::OPT_nostartfiles)) {
6274 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006275 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006276 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006277 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006278 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006279 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006280 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006281 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006282 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006283 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006284 CmdArgs.push_back(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006285 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006286 }
6287 }
6288
6289 Args.AddAllArgs(CmdArgs, options::OPT_L);
6290 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6291 Args.AddAllArgs(CmdArgs, options::OPT_e);
6292
Daniel Dunbar54423b22010-09-17 00:24:54 +00006293 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00006294
6295 if (!Args.hasArg(options::OPT_nostdlib) &&
6296 !Args.hasArg(options::OPT_nodefaultlibs)) {
6297 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6298 // rpaths
6299 CmdArgs.push_back("-L/usr/lib/gcc41");
6300
6301 if (!Args.hasArg(options::OPT_static)) {
6302 CmdArgs.push_back("-rpath");
6303 CmdArgs.push_back("/usr/lib/gcc41");
6304
6305 CmdArgs.push_back("-rpath-link");
6306 CmdArgs.push_back("/usr/lib/gcc41");
6307
6308 CmdArgs.push_back("-rpath");
6309 CmdArgs.push_back("/usr/lib");
6310
6311 CmdArgs.push_back("-rpath-link");
6312 CmdArgs.push_back("/usr/lib");
6313 }
6314
Rafael Espindola38360b32010-07-20 12:59:03 +00006315 if (D.CCCIsCXX) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006316 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00006317 CmdArgs.push_back("-lm");
6318 }
6319
Daniel Dunbarcc912342009-05-02 18:28:39 +00006320 if (Args.hasArg(options::OPT_shared)) {
6321 CmdArgs.push_back("-lgcc_pic");
6322 } else {
6323 CmdArgs.push_back("-lgcc");
6324 }
6325
6326
6327 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00006328 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00006329
6330 if (!Args.hasArg(options::OPT_nolibc)) {
6331 CmdArgs.push_back("-lc");
6332 }
6333
6334 if (Args.hasArg(options::OPT_shared)) {
6335 CmdArgs.push_back("-lgcc_pic");
6336 } else {
6337 CmdArgs.push_back("-lgcc");
6338 }
6339 }
6340
6341 if (!Args.hasArg(options::OPT_nostdlib) &&
6342 !Args.hasArg(options::OPT_nostartfiles)) {
6343 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006344 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006345 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006346 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006347 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006348 getToolChain().GetFilePath("crtendS.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006349 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006350 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006351 }
6352
Bill Wendling08760582011-06-27 19:15:03 +00006353 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006354
Daniel Dunbarcc912342009-05-02 18:28:39 +00006355 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006356 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006357 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00006358}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006359
6360void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6361 const InputInfo &Output,
6362 const InputInfoList &Inputs,
6363 const ArgList &Args,
6364 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006365 ArgStringList CmdArgs;
6366
6367 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00006368 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6369 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006370 } else {
6371 assert(Output.isNothing() && "Invalid output.");
6372 }
6373
6374 if (!Args.hasArg(options::OPT_nostdlib) &&
6375 !Args.hasArg(options::OPT_nostartfiles)) {
6376 CmdArgs.push_back("-defaultlib:libcmt");
6377 }
6378
6379 CmdArgs.push_back("-nologo");
6380
Michael J. Spencere2f49362012-06-18 16:56:04 +00006381 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6382
6383 // Add filenames immediately.
6384 for (InputInfoList::const_iterator
6385 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6386 if (it->isFilename())
6387 CmdArgs.push_back(it->getFilename());
6388 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006389
6390 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00006391 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00006392 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6393}