blob: 393f4b47ffe0f10ec0245559fe3a86dcbcb57bc2 [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000011#include "InputInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000012#include "ToolChains.h"
Josh Mageee0fc1a82014-02-11 01:35:14 +000013#include "clang/Basic/LangOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "clang/Basic/ObjCRuntime.h"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000015#include "clang/Basic/Version.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000016#include "clang/Driver/Action.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000018#include "clang/Driver/Driver.h"
19#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000020#include "clang/Driver/Job.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000021#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000022#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000023#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000024#include "clang/Driver/Util.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000026#include "llvm/ADT/StringExtras.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000027#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000028#include "llvm/ADT/Twine.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000029#include "llvm/Option/Arg.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Option/Option.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000032#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000033#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000034#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000035#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000036#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000037#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000038#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000039#include "llvm/Support/raw_ostream.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000040#include <sys/stat.h>
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000041
Daniel Dunbar1a093d22009-03-18 06:00:36 +000042using namespace clang::driver;
43using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000044using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000045using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000046
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000047static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
48 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
49 options::OPT_fpic, options::OPT_fno_pic,
50 options::OPT_fPIE, options::OPT_fno_PIE,
51 options::OPT_fpie, options::OPT_fno_pie);
52 if (!LastPICArg)
53 return;
54 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
55 LastPICArg->getOption().matches(options::OPT_fpic) ||
56 LastPICArg->getOption().matches(options::OPT_fPIE) ||
57 LastPICArg->getOption().matches(options::OPT_fpie)) {
58 CmdArgs.push_back("-KPIC");
59 }
60}
61
Daniel Dunbar64198ef2009-09-10 01:21:05 +000062/// CheckPreprocessingOptions - Perform some validation of preprocessing
63/// arguments that is shared with gcc.
64static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
65 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Hans Wennborg70850d82013-07-18 20:29:38 +000066 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
Chris Lattner0e62c1c2011-07-23 10:55:15 +000067 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar64198ef2009-09-10 01:21:05 +000068 << A->getAsString(Args) << "-E";
69}
70
Daniel Dunbar4eadb602009-09-10 01:21:12 +000071/// CheckCodeGenerationOptions - Perform some validation of code generation
72/// arguments that is shared with gcc.
73static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
74 // In gcc, only ARM checks this, but it seems reasonable to check universally.
75 if (Args.hasArg(options::OPT_static))
76 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
77 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000078 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000079 << A->getAsString(Args) << "-static";
80}
81
Chris Lattnerbf2803f2010-03-29 17:55:58 +000082// Quote target names for inclusion in GNU Make dependency files.
83// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000084static void QuoteTarget(StringRef Target,
85 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000086 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
87 switch (Target[i]) {
88 case ' ':
89 case '\t':
90 // Escape the preceding backslashes
91 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
92 Res.push_back('\\');
93
94 // Escape the space/tab
95 Res.push_back('\\');
96 break;
97 case '$':
98 Res.push_back('$');
99 break;
100 case '#':
101 Res.push_back('\\');
102 break;
103 default:
104 break;
105 }
106
107 Res.push_back(Target[i]);
108 }
109}
110
Bill Wendlingc0938f32012-03-12 22:10:06 +0000111static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000112 ArgStringList &CmdArgs,
113 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000114 const char *EnvVar) {
115 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000116 bool CombinedArg = false;
117
Bill Wendling281ca292012-03-12 21:22:35 +0000118 if (!DirList)
119 return; // Nothing to do.
120
Chad Rosier616e8a52012-10-30 21:42:09 +0000121 StringRef Name(ArgName);
122 if (Name.equals("-I") || Name.equals("-L"))
123 CombinedArg = true;
124
Bill Wendling281ca292012-03-12 21:22:35 +0000125 StringRef Dirs(DirList);
126 if (Dirs.empty()) // Empty string should not add '.'.
127 return;
128
129 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000130 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000131 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000132 if (CombinedArg) {
133 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
134 } else {
135 CmdArgs.push_back(ArgName);
136 CmdArgs.push_back(".");
137 }
Bill Wendling281ca292012-03-12 21:22:35 +0000138 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000139 if (CombinedArg) {
140 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
141 } else {
142 CmdArgs.push_back(ArgName);
143 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
144 }
Bill Wendling281ca292012-03-12 21:22:35 +0000145 }
Nico Weber89355782012-03-19 15:00:03 +0000146 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000147 }
148
149 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000150 if (CombinedArg) {
151 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
152 } else {
153 CmdArgs.push_back(ArgName);
154 CmdArgs.push_back(".");
155 }
Bill Wendling281ca292012-03-12 21:22:35 +0000156 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000157 if (CombinedArg) {
158 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
159 } else {
160 CmdArgs.push_back(ArgName);
161 CmdArgs.push_back(Args.MakeArgString(Dirs));
162 }
Bill Wendling281ca292012-03-12 21:22:35 +0000163 }
164}
165
Daniel Dunbar54423b22010-09-17 00:24:54 +0000166static void AddLinkerInputs(const ToolChain &TC,
167 const InputInfoList &Inputs, const ArgList &Args,
168 ArgStringList &CmdArgs) {
169 const Driver &D = TC.getDriver();
170
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000171 // Add extra linker input arguments which are not treated as inputs
172 // (constructed via -Xarch_).
173 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
174
Daniel Dunbar54423b22010-09-17 00:24:54 +0000175 for (InputInfoList::const_iterator
176 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
177 const InputInfo &II = *it;
178
179 if (!TC.HasNativeLLVMSupport()) {
180 // Don't try to pass LLVM inputs unless we have native support.
181 if (II.getType() == types::TY_LLVM_IR ||
182 II.getType() == types::TY_LTO_IR ||
183 II.getType() == types::TY_LLVM_BC ||
184 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000185 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000186 << TC.getTripleString();
187 }
188
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000189 // Add filenames immediately.
190 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000191 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000192 continue;
193 }
194
195 // Otherwise, this is a linker input argument.
196 const Arg &A = II.getInputArg();
197
198 // Handle reserved library options.
199 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000200 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000201 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
202 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000203 } else
204 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000205 }
Bill Wendling281ca292012-03-12 21:22:35 +0000206
207 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000208 // and only supported on native toolchains.
209 if (!TC.isCrossCompiling())
210 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000211}
212
John McCall31168b02011-06-15 23:02:42 +0000213/// \brief Determine whether Objective-C automated reference counting is
214/// enabled.
215static bool isObjCAutoRefCount(const ArgList &Args) {
216 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
217}
218
Ted Kremeneke65b0862012-03-06 20:05:56 +0000219/// \brief Determine whether we are linking the ObjC runtime.
220static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000221 if (isObjCAutoRefCount(Args)) {
222 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000223 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000224 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000225 return Args.hasArg(options::OPT_fobjc_link_runtime);
226}
227
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000228static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000229 // Don't forward inputs from the original command line. They are added from
230 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000231 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000232 !O.hasFlag(options::DriverOption) &&
233 !O.hasFlag(options::LinkerInput);
234}
235
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000236void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000237 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000238 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000239 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000240 ArgStringList &CmdArgs,
241 const InputInfo &Output,
242 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000243 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000244
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000245 CheckPreprocessingOptions(D, Args);
246
247 Args.AddLastArg(CmdArgs, options::OPT_C);
248 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000249
250 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000251 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000252 (A = Args.getLastArg(options::OPT_MD)) ||
253 (A = Args.getLastArg(options::OPT_MMD))) {
254 // Determine the output location.
255 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000256 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000257 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000258 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000259 } else if (Output.getType() == types::TY_Dependencies) {
260 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000261 } else if (A->getOption().matches(options::OPT_M) ||
262 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000263 DepFile = "-";
264 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000265 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000266 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000267 }
268 CmdArgs.push_back("-dependency-file");
269 CmdArgs.push_back(DepFile);
270
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000271 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000272 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
273 const char *DepTarget;
274
275 // If user provided -o, that is the dependency target, except
276 // when we are only generating a dependency file.
277 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
278 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000279 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000280 } else {
281 // Otherwise derive from the base input.
282 //
283 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000284 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000285 llvm::sys::path::replace_extension(P, "o");
286 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000287 }
288
289 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000290 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000291 QuoteTarget(DepTarget, Quoted);
292 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000293 }
294
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000295 if (A->getOption().matches(options::OPT_M) ||
296 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000297 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000298
299 if (isa<PrecompileJobAction>(JA))
300 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000301 }
302
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000303 if (Args.hasArg(options::OPT_MG)) {
304 if (!A || A->getOption().matches(options::OPT_MD) ||
305 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000306 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000307 CmdArgs.push_back("-MG");
308 }
309
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000310 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000311
312 // Convert all -MQ <target> args to -MT <quoted target>
313 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
314 options::OPT_MQ),
315 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000316 const Arg *A = *it;
317 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000318
Daniel Dunbara442fd52010-06-11 22:00:13 +0000319 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000320 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000321 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000322 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000323 CmdArgs.push_back(Args.MakeArgString(Quoted));
324
325 // -MT flag - no change
326 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000327 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000328 }
329 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000330
Douglas Gregor111af7d2009-04-18 00:34:01 +0000331 // Add -i* options, and automatically translate to
332 // -include-pch/-include-pth for transparent PCH support. It's
333 // wonky, but we include looking for .gch so we can support seamless
334 // replacement into a build system already set up to be generating
335 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000336 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000337 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
338 ie = Args.filtered_end(); it != ie; ++it) {
339 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000340
341 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000342 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
343 RenderedImplicitInclude = true;
344
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000345 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000346 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000347
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000348 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000349 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000350 SmallString<128> P(A->getValue());
351 // We want the files to have a name like foo.h.pch. Add a dummy extension
352 // so that replace_extension does the right thing.
353 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000354 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000355 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000356 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000357 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000358 }
359
Douglas Gregor111af7d2009-04-18 00:34:01 +0000360 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000361 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000362 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000363 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000364 }
365
Douglas Gregor111af7d2009-04-18 00:34:01 +0000366 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000367 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000368 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000369 FoundPCH = UsePCH;
370 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000371 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000372 }
373
374 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000375 if (IsFirstImplicitInclude) {
376 A->claim();
377 if (UsePCH)
378 CmdArgs.push_back("-include-pch");
379 else
380 CmdArgs.push_back("-include-pth");
381 CmdArgs.push_back(Args.MakeArgString(P.str()));
382 continue;
383 } else {
384 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000385 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000386 << P.str() << A->getAsString(Args);
387 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000388 }
389 }
390
391 // Not translated, render as usual.
392 A->claim();
393 A->render(Args, CmdArgs);
394 }
395
396 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000397 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
398 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000399
400 // Add -Wp, and -Xassembler if using the preprocessor.
401
402 // FIXME: There is a very unfortunate problem here, some troubled
403 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
404 // really support that we would have to parse and then translate
405 // those options. :(
406 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
407 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000408
409 // -I- is a deprecated GCC feature, reject it.
410 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000411 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000412
413 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
414 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000415 StringRef sysroot = C.getSysRoot();
416 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000417 if (!Args.hasArg(options::OPT_isysroot)) {
418 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000419 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000420 }
421 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000422
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000423 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000424 // FIXME: We should probably sink the logic for handling these from the
425 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000426 // CPATH - included following the user specified includes (but prior to
427 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000428 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000429 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000430 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000431 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000432 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000433 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000434 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000435 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000436 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000437
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000438 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000439 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000440 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000441
442 // Add system include arguments.
443 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000444}
445
Amara Emerson703da2e2013-10-31 09:32:33 +0000446/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting.
447//
448// FIXME: tblgen this.
449static std::string getAArch64TargetCPU(const ArgList &Args,
450 const llvm::Triple &Triple) {
451 // FIXME: Warn on inconsistent use of -mcpu and -march.
452
453 // If we have -mcpu=, use that.
454 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
455 StringRef MCPU = A->getValue();
456 // Handle -mcpu=native.
457 if (MCPU == "native")
458 return llvm::sys::getHostCPUName();
459 else
460 return MCPU;
461 }
462
463 return "generic";
464}
465
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000466// FIXME: Move to target hook.
467static bool isSignedCharDefault(const llvm::Triple &Triple) {
468 switch (Triple.getArch()) {
469 default:
470 return true;
471
Tim Northover9bb857a2013-01-31 12:13:10 +0000472 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000473 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000474 case llvm::Triple::arm:
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000475 case llvm::Triple::ppc:
476 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000477 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000478 return true;
479 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000480
Bill Schmidt778d3872013-07-26 01:36:11 +0000481 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000482 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000483 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000484 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000485 }
486}
487
Robert Lytton0e076492013-08-13 09:43:10 +0000488static bool isNoCommonDefault(const llvm::Triple &Triple) {
489 switch (Triple.getArch()) {
490 default:
491 return false;
492
493 case llvm::Triple::xcore:
494 return true;
495 }
496}
497
Chad Rosiercfbfc582012-04-04 20:51:35 +0000498// Handle -mfpu=.
499//
500// FIXME: Centralize feature selection, defaulting shouldn't be also in the
501// frontend target.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000502static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
503 const ArgList &Args,
504 std::vector<const char *> &Features) {
505 StringRef FPU = A->getValue();
506 if (FPU == "fp-armv8") {
507 Features.push_back("+fp-armv8");
508 } else if (FPU == "neon-fp-armv8") {
509 Features.push_back("+fp-armv8");
510 Features.push_back("+neon");
511 } else if (FPU == "crypto-neon-fp-armv8") {
512 Features.push_back("+fp-armv8");
513 Features.push_back("+neon");
514 Features.push_back("+crypto");
515 } else if (FPU == "neon") {
516 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000517 } else
518 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
519}
520
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000521// Handle -mhwdiv=.
522static void getARMHWDivFeatures(const Driver &D, const Arg *A,
523 const ArgList &Args,
524 std::vector<const char *> &Features) {
525 StringRef HWDiv = A->getValue();
526 if (HWDiv == "arm") {
527 Features.push_back("+hwdiv-arm");
528 Features.push_back("-hwdiv");
529 } else if (HWDiv == "thumb") {
530 Features.push_back("-hwdiv-arm");
531 Features.push_back("+hwdiv");
532 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
533 Features.push_back("+hwdiv-arm");
534 Features.push_back("+hwdiv");
535 } else if (HWDiv == "none") {
536 Features.push_back("-hwdiv-arm");
537 Features.push_back("-hwdiv");
538 } else
539 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
540}
541
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000542// Handle -mfpu=.
543//
544// FIXME: Centralize feature selection, defaulting shouldn't be also in the
545// frontend target.
546static void getARMFPUFeatures(const Driver &D, const Arg *A,
547 const ArgList &Args,
548 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000549 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000550
551 // Set the target features based on the FPU.
552 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
553 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000554 Features.push_back("-vfp2");
555 Features.push_back("-vfp3");
556 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000557 } else if (FPU == "vfp") {
558 Features.push_back("+vfp2");
559 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000560 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000561 Features.push_back("+vfp3");
562 Features.push_back("+d16");
563 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000564 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000565 Features.push_back("+vfp3");
566 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000567 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
568 Features.push_back("+vfp4");
569 Features.push_back("+d16");
570 Features.push_back("-neon");
571 } else if (FPU == "vfp4" || FPU == "vfpv4") {
572 Features.push_back("+vfp4");
573 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000574 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
575 Features.push_back("+vfp4");
576 Features.push_back("+d16");
577 Features.push_back("+fp-only-sp");
578 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000579 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000580 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000581 Features.push_back("-neon");
582 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000583 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000584 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000585 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000586 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000587 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000588 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000589 Features.push_back("+neon");
590 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000591 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000592 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000593 } else if (FPU == "none") {
594 Features.push_back("-vfp2");
595 Features.push_back("-vfp3");
596 Features.push_back("-vfp4");
597 Features.push_back("-fp-armv8");
598 Features.push_back("-crypto");
599 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000600 } else
601 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
602}
603
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000604// Select the float ABI as determined by -msoft-float, -mhard-float, and
605// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000606StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
607 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000608 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000609 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
610 options::OPT_mhard_float,
611 options::OPT_mfloat_abi_EQ)) {
612 if (A->getOption().matches(options::OPT_msoft_float))
613 FloatABI = "soft";
614 else if (A->getOption().matches(options::OPT_mhard_float))
615 FloatABI = "hard";
616 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000617 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000618 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000619 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000620 << A->getAsString(Args);
621 FloatABI = "soft";
622 }
623 }
624 }
625
626 // If unspecified, choose the default based on the platform.
627 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000628 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000629 case llvm::Triple::Darwin:
630 case llvm::Triple::MacOSX:
631 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000632 // Darwin defaults to "softfp" for v6 and v7.
633 //
634 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000635 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000636 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000637 if (StringRef(ArchName).startswith("v6") ||
638 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000639 FloatABI = "softfp";
640 else
641 FloatABI = "soft";
642 break;
643 }
644
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000645 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000646 switch(Triple.getEnvironment()) {
647 case llvm::Triple::GNUEABIHF:
648 FloatABI = "hard";
649 break;
650 default:
651 // FreeBSD defaults to soft float
652 FloatABI = "soft";
653 break;
654 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000655 break;
656
Daniel Dunbar78485922009-09-10 23:00:09 +0000657 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000658 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000659 case llvm::Triple::GNUEABIHF:
660 FloatABI = "hard";
661 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000662 case llvm::Triple::GNUEABI:
663 FloatABI = "softfp";
664 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000665 case llvm::Triple::EABIHF:
666 FloatABI = "hard";
667 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000668 case llvm::Triple::EABI:
669 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
670 FloatABI = "softfp";
671 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000672 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000673 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000674 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000675 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000676 FloatABI = "softfp";
677 else
678 FloatABI = "soft";
679 break;
680 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000681 default:
682 // Assume "soft", but warn the user we are guessing.
683 FloatABI = "soft";
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000684 // *-macho defaults to "soft"
685 if (Triple.getOS() == llvm::Triple::UnknownOS &&
686 Triple.getObjectFormat() == llvm::Triple::MachO)
687 break;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000688 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000689 break;
690 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000691 }
692 }
693
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000694 return FloatABI;
695}
696
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000697static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
698 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000699 std::vector<const char *> &Features,
700 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000701 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000702 if (!ForAS) {
703 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
704 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
705 // stripped out by the ARM target. We should probably pass this a new
706 // -target-option, which is handled by the -cc1/-cc1as invocation.
707 //
708 // FIXME2: For consistency, it would be ideal if we set up the target
709 // machine state the same when using the frontend or the assembler. We don't
710 // currently do that for the assembler, we pass the options directly to the
711 // backend and never even instantiate the frontend TargetInfo. If we did,
712 // and used its handleTargetFeatures hook, then we could ensure the
713 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000714
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000715 // Use software floating point operations?
716 if (FloatABI == "soft")
717 Features.push_back("+soft-float");
718
719 // Use software floating point argument passing?
720 if (FloatABI != "hard")
721 Features.push_back("+soft-float-abi");
722 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000723
724 // Honor -mfpu=.
725 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000726 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000727 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
728 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000729
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000730 // Setting -msoft-float effectively disables NEON because of the GCC
731 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000732 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000733 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000734 // Also need to explicitly disable features which imply NEON.
735 Features.push_back("-crypto");
736 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000737
738 // En/disable crc
739 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
740 options::OPT_mnocrc)) {
741 if (A->getOption().matches(options::OPT_mcrc))
742 Features.push_back("+crc");
743 else
744 Features.push_back("-crc");
745 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000746}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000747
748void Clang::AddARMTargetArgs(const ArgList &Args,
749 ArgStringList &CmdArgs,
750 bool KernelOrKext) const {
751 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000752 // Get the effective triple, which takes into account the deployment target.
753 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
754 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000755 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000756
757 // Select the ABI to use.
758 //
759 // FIXME: Support -meabi.
760 const char *ABIName = 0;
761 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000762 ABIName = A->getValue();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000763 } else if (Triple.isOSDarwin()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000764 // The backend is hardwired to assume AAPCS for M-class processors, ensure
765 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000766 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000767 (Triple.getOS() == llvm::Triple::UnknownOS &&
768 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000769 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000770 ABIName = "aapcs";
771 } else {
772 ABIName = "apcs-gnu";
773 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000774 } else {
775 // Select the default based on the platform.
776 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000777 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000778 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000779 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000780 ABIName = "aapcs-linux";
781 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000782 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000783 case llvm::Triple::EABI:
784 ABIName = "aapcs";
785 break;
786 default:
787 ABIName = "apcs-gnu";
788 }
789 }
790 CmdArgs.push_back("-target-abi");
791 CmdArgs.push_back(ABIName);
792
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000793 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000794 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000795 if (FloatABI == "soft") {
796 // Floating point operations and argument passing are soft.
797 //
798 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000799 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000800 CmdArgs.push_back("-mfloat-abi");
801 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000802 } else if (FloatABI == "softfp") {
803 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000804 CmdArgs.push_back("-mfloat-abi");
805 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000806 } else {
807 // Floating point operations and argument passing are hard.
808 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000809 CmdArgs.push_back("-mfloat-abi");
810 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000811 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000812
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000813 // Kernel code has more strict alignment requirements.
814 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000815 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000816 CmdArgs.push_back("-backend-option");
817 CmdArgs.push_back("-arm-long-calls");
818 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000819
Daniel Dunbar12100e22011-03-22 16:48:17 +0000820 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000821 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000822
823 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000824 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000825 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000826 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000827
828 // Setting -mno-global-merge disables the codegen global merge pass. Setting
829 // -mglobal-merge has no effect as the pass is enabled by default.
830 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
831 options::OPT_mno_global_merge)) {
832 if (A->getOption().matches(options::OPT_mno_global_merge))
833 CmdArgs.push_back("-mno-global-merge");
834 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000835
Bob Wilson9c8af452013-04-11 18:53:25 +0000836 if (!Args.hasFlag(options::OPT_mimplicit_float,
837 options::OPT_mno_implicit_float,
838 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000839 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000840
841 // llvm does not support reserving registers in general. There is support
842 // for reserving r9 on ARM though (defined as a platform-specific register
843 // in ARM EABI).
844 if (Args.hasArg(options::OPT_ffixed_r9)) {
845 CmdArgs.push_back("-backend-option");
846 CmdArgs.push_back("-arm-reserve-r9");
847 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000848}
849
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000850// Get CPU and ABI names. They are not independent
851// so we have to calculate them together.
852static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000853 const llvm::Triple &Triple,
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000854 StringRef &CPUName,
855 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000856 const char *DefMips32CPU = "mips32r2";
857 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000858
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000859 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000860 options::OPT_mcpu_EQ))
861 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000862
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000863 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000864 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000865 // Convert a GNU style Mips ABI name to the name
866 // accepted by LLVM Mips backend.
867 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
868 .Case("32", "o32")
869 .Case("64", "n64")
870 .Default(ABIName);
871 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000872
873 // Setup default CPU and ABI names.
874 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000875 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000876 default:
877 llvm_unreachable("Unexpected triple arch name");
878 case llvm::Triple::mips:
879 case llvm::Triple::mipsel:
880 CPUName = DefMips32CPU;
881 break;
882 case llvm::Triple::mips64:
883 case llvm::Triple::mips64el:
884 CPUName = DefMips64CPU;
885 break;
886 }
887 }
888
889 if (!ABIName.empty()) {
890 // Deduce CPU name from ABI name.
891 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000892 .Cases("32", "o32", "eabi", DefMips32CPU)
893 .Cases("n32", "n64", "64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000894 .Default("");
895 }
896 else if (!CPUName.empty()) {
897 // Deduce ABI name from CPU name.
898 ABIName = llvm::StringSwitch<const char *>(CPUName)
899 .Cases("mips32", "mips32r2", "o32")
900 .Cases("mips64", "mips64r2", "n64")
901 .Default("");
902 }
903
904 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000905}
906
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000907// Convert ABI name to the GNU tools acceptable variant.
908static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
909 return llvm::StringSwitch<llvm::StringRef>(ABI)
910 .Case("o32", "32")
911 .Case("n64", "64")
912 .Default(ABI);
913}
914
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000915// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
916// and -mfloat-abi=.
917static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000918 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000919 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000920 options::OPT_mhard_float,
921 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000922 if (A->getOption().matches(options::OPT_msoft_float))
923 FloatABI = "soft";
924 else if (A->getOption().matches(options::OPT_mhard_float))
925 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000926 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000927 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000928 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000929 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000930 FloatABI = "hard";
931 }
932 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000933 }
934
935 // If unspecified, choose the default based on the platform.
936 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000937 // Assume "hard", because it's a default value used by gcc.
938 // When we start to recognize specific target MIPS processors,
939 // we will be able to select the default more correctly.
940 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000941 }
942
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000943 return FloatABI;
944}
945
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000946static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000947 std::vector<const char *> &Features,
948 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000949 StringRef FeatureName) {
950 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000951 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000952 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000953 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000954 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000955 }
956}
957
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000958static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
959 std::vector<const char *> &Features) {
960 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +0000961 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000962 // FIXME: Note, this is a hack. We need to pass the selected float
963 // mode to the MipsTargetInfoBase to define appropriate macros there.
964 // Now it is the only method.
965 Features.push_back("+soft-float");
966 }
967
Simon Atanasyan22127ce2013-09-24 09:09:16 +0000968 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
969 if (StringRef(A->getValue()) == "2008")
970 Features.push_back("+nan2008");
971 }
972
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000973 AddTargetFeature(Args, Features, options::OPT_msingle_float,
974 options::OPT_mdouble_float, "single-float");
975 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
976 "mips16");
977 AddTargetFeature(Args, Features, options::OPT_mmicromips,
978 options::OPT_mno_micromips, "micromips");
979 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
980 "dsp");
981 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
982 "dspr2");
983 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
984 "msa");
Daniel Sanders94694172013-10-17 14:55:58 +0000985 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
986 "fp64");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000987}
988
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000989void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +0000990 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000991 const Driver &D = getToolChain().getDriver();
992 StringRef CPUName;
993 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000994 const llvm::Triple &Triple = getToolChain().getTriple();
995 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000996
997 CmdArgs.push_back("-target-abi");
998 CmdArgs.push_back(ABIName.data());
999
1000 StringRef FloatABI = getMipsFloatABI(D, Args);
1001
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001002 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001003 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001004 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001005 CmdArgs.push_back("-mfloat-abi");
1006 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001007 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001008 else {
1009 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001010 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001011 CmdArgs.push_back("-mfloat-abi");
1012 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001013 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001014
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001015 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1016 if (A->getOption().matches(options::OPT_mxgot)) {
1017 CmdArgs.push_back("-mllvm");
1018 CmdArgs.push_back("-mxgot");
1019 }
1020 }
1021
Simon Atanasyanc580b322013-05-11 06:33:44 +00001022 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1023 options::OPT_mno_ldc1_sdc1)) {
1024 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1025 CmdArgs.push_back("-mllvm");
1026 CmdArgs.push_back("-mno-ldc1-sdc1");
1027 }
1028 }
1029
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001030 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1031 options::OPT_mno_check_zero_division)) {
1032 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1033 CmdArgs.push_back("-mllvm");
1034 CmdArgs.push_back("-mno-check-zero-division");
1035 }
1036 }
1037
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001038 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001039 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001040 CmdArgs.push_back("-mllvm");
1041 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1042 A->claim();
1043 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001044}
1045
Hal Finkel8eb59282012-06-11 22:35:19 +00001046/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1047static std::string getPPCTargetCPU(const ArgList &Args) {
1048 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001049 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001050
1051 if (CPUName == "native") {
1052 std::string CPU = llvm::sys::getHostCPUName();
1053 if (!CPU.empty() && CPU != "generic")
1054 return CPU;
1055 else
1056 return "";
1057 }
1058
1059 return llvm::StringSwitch<const char *>(CPUName)
1060 .Case("common", "generic")
1061 .Case("440", "440")
1062 .Case("440fp", "440")
1063 .Case("450", "450")
1064 .Case("601", "601")
1065 .Case("602", "602")
1066 .Case("603", "603")
1067 .Case("603e", "603e")
1068 .Case("603ev", "603ev")
1069 .Case("604", "604")
1070 .Case("604e", "604e")
1071 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001072 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001073 .Case("G3", "g3")
1074 .Case("7400", "7400")
1075 .Case("G4", "g4")
1076 .Case("7450", "7450")
1077 .Case("G4+", "g4+")
1078 .Case("750", "750")
1079 .Case("970", "970")
1080 .Case("G5", "g5")
1081 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001082 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001083 .Case("e500mc", "e500mc")
1084 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001085 .Case("power3", "pwr3")
1086 .Case("power4", "pwr4")
1087 .Case("power5", "pwr5")
1088 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001089 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001090 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001091 .Case("power7", "pwr7")
Bill Schmidt38378a02013-02-01 20:23:10 +00001092 .Case("pwr3", "pwr3")
1093 .Case("pwr4", "pwr4")
1094 .Case("pwr5", "pwr5")
1095 .Case("pwr5x", "pwr5x")
1096 .Case("pwr6", "pwr6")
1097 .Case("pwr6x", "pwr6x")
1098 .Case("pwr7", "pwr7")
Hal Finkel8eb59282012-06-11 22:35:19 +00001099 .Case("powerpc", "ppc")
1100 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001101 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001102 .Default("");
1103 }
1104
1105 return "";
1106}
1107
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001108static void getPPCTargetFeatures(const ArgList &Args,
1109 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001110 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1111 ie = Args.filtered_end();
1112 it != ie; ++it) {
1113 StringRef Name = (*it)->getOption().getName();
1114 (*it)->claim();
1115
1116 // Skip over "-m".
1117 assert(Name.startswith("m") && "Invalid feature name.");
1118 Name = Name.substr(1);
1119
1120 bool IsNegative = Name.startswith("no-");
1121 if (IsNegative)
1122 Name = Name.substr(3);
1123
1124 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1125 // pass the correct option to the backend while calling the frontend
1126 // option the same.
1127 // TODO: Change the LLVM backend option maybe?
1128 if (Name == "mfcrf")
1129 Name = "mfocrf";
1130
1131 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1132 }
1133
1134 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001135 AddTargetFeature(Args, Features, options::OPT_faltivec,
1136 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001137}
1138
Tom Stellard6674c702013-04-01 20:56:53 +00001139/// Get the (LLVM) name of the R600 gpu we are targeting.
1140static std::string getR600TargetGPU(const ArgList &Args) {
1141 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001142 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001143 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001144 .Cases("rv630", "rv635", "r600")
1145 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001146 .Case("rv740", "rv770")
1147 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001148 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001149 .Case("hemlock", "cypress")
1150 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001151 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001152 }
1153 return "";
1154}
1155
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001156static void getSparcTargetFeatures(const ArgList &Args,
1157 std::vector<const char *> Features) {
1158 bool SoftFloatABI = true;
1159 if (Arg *A =
1160 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1161 if (A->getOption().matches(options::OPT_mhard_float))
1162 SoftFloatABI = false;
1163 }
1164 if (SoftFloatABI)
1165 Features.push_back("+soft-float");
1166}
1167
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001168void Clang::AddSparcTargetArgs(const ArgList &Args,
1169 ArgStringList &CmdArgs) const {
1170 const Driver &D = getToolChain().getDriver();
1171
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001172 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001173 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001174 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1175 options::OPT_mhard_float)) {
1176 if (A->getOption().matches(options::OPT_msoft_float))
1177 FloatABI = "soft";
1178 else if (A->getOption().matches(options::OPT_mhard_float))
1179 FloatABI = "hard";
1180 }
1181
1182 // If unspecified, choose the default based on the platform.
1183 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001184 // Assume "soft", but warn the user we are guessing.
1185 FloatABI = "soft";
1186 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001187 }
1188
1189 if (FloatABI == "soft") {
1190 // Floating point operations and argument passing are soft.
1191 //
1192 // FIXME: This changes CPP defines, we need -target-soft-float.
1193 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001194 } else {
1195 assert(FloatABI == "hard" && "Invalid float abi!");
1196 CmdArgs.push_back("-mhard-float");
1197 }
1198}
1199
Richard Sandiford4652d892013-07-19 16:51:51 +00001200static const char *getSystemZTargetCPU(const ArgList &Args) {
1201 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1202 return A->getValue();
1203 return "z10";
1204}
1205
Chandler Carruth953fb082013-01-13 11:46:33 +00001206static const char *getX86TargetCPU(const ArgList &Args,
1207 const llvm::Triple &Triple) {
1208 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001209 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001210 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001211 return "core-avx2";
1212
Chandler Carruth953fb082013-01-13 11:46:33 +00001213 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001214 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001215
1216 // FIXME: Reject attempts to use -march=native unless the target matches
1217 // the host.
1218 //
1219 // FIXME: We should also incorporate the detected target features for use
1220 // with -native.
1221 std::string CPU = llvm::sys::getHostCPUName();
1222 if (!CPU.empty() && CPU != "generic")
1223 return Args.MakeArgString(CPU);
1224 }
1225
1226 // Select the default CPU if none was given (or detection failed).
1227
1228 if (Triple.getArch() != llvm::Triple::x86_64 &&
1229 Triple.getArch() != llvm::Triple::x86)
1230 return 0; // This routine is only handling x86 targets.
1231
1232 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1233
1234 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001235 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001236 if (Triple.getArchName() == "x86_64h")
1237 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001238 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001239 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001240
Alexey Bataev286d1b92014-01-31 04:07:13 +00001241 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001242 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001243 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001244
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001245 // Everything else goes to x86-64 in 64-bit mode.
1246 if (Is64Bit)
1247 return "x86-64";
1248
1249 switch (Triple.getOS()) {
1250 case llvm::Triple::FreeBSD:
1251 case llvm::Triple::NetBSD:
1252 case llvm::Triple::OpenBSD:
1253 return "i486";
1254 case llvm::Triple::Haiku:
1255 return "i586";
1256 case llvm::Triple::Bitrig:
1257 return "i686";
1258 default:
1259 // Fallback to p4.
1260 return "pentium4";
1261 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001262}
1263
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001264static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1265 switch(T.getArch()) {
1266 default:
1267 return "";
1268
Amara Emerson703da2e2013-10-31 09:32:33 +00001269 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001270 case llvm::Triple::aarch64_be:
Amara Emerson703da2e2013-10-31 09:32:33 +00001271 return getAArch64TargetCPU(Args, T);
1272
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001273 case llvm::Triple::arm:
1274 case llvm::Triple::thumb:
Bernard Ogden31561762013-12-12 13:27:11 +00001275 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001276
1277 case llvm::Triple::mips:
1278 case llvm::Triple::mipsel:
1279 case llvm::Triple::mips64:
1280 case llvm::Triple::mips64el: {
1281 StringRef CPUName;
1282 StringRef ABIName;
1283 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1284 return CPUName;
1285 }
1286
1287 case llvm::Triple::ppc:
1288 case llvm::Triple::ppc64:
1289 case llvm::Triple::ppc64le: {
1290 std::string TargetCPUName = getPPCTargetCPU(Args);
1291 // LLVM may default to generating code for the native CPU,
1292 // but, like gcc, we default to a more generic option for
1293 // each architecture. (except on Darwin)
1294 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1295 if (T.getArch() == llvm::Triple::ppc64)
1296 TargetCPUName = "ppc64";
1297 else if (T.getArch() == llvm::Triple::ppc64le)
1298 TargetCPUName = "ppc64le";
1299 else
1300 TargetCPUName = "ppc";
1301 }
1302 return TargetCPUName;
1303 }
1304
1305 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001306 case llvm::Triple::sparcv9:
1307 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001308 return A->getValue();
1309 return "";
1310
1311 case llvm::Triple::x86:
1312 case llvm::Triple::x86_64:
1313 return getX86TargetCPU(Args, T);
1314
1315 case llvm::Triple::hexagon:
1316 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1317
1318 case llvm::Triple::systemz:
1319 return getSystemZTargetCPU(Args);
1320
1321 case llvm::Triple::r600:
1322 return getR600TargetGPU(Args);
1323 }
1324}
1325
Alp Tokerce365ca2013-12-02 12:43:03 +00001326static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1327 ArgStringList &CmdArgs) {
1328 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1329 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1330 // forward.
1331 CmdArgs.push_back("-plugin");
1332 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1333 CmdArgs.push_back(Args.MakeArgString(Plugin));
1334
1335 // Try to pass driver level flags relevant to LTO code generation down to
1336 // the plugin.
1337
1338 // Handle flags for selecting CPU variants.
1339 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1340 if (!CPU.empty())
1341 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1342}
1343
Jim Grosbach82eee262013-11-16 00:53:35 +00001344static void getX86TargetFeatures(const llvm::Triple &Triple,
1345 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001346 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001347 if (Triple.getArchName() == "x86_64h") {
1348 // x86_64h implies quite a few of the more modern subtarget features
1349 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1350 Features.push_back("-rdrnd");
1351 Features.push_back("-aes");
1352 Features.push_back("-pclmul");
1353 Features.push_back("-rtm");
1354 Features.push_back("-hle");
1355 Features.push_back("-fsgsbase");
1356 }
1357
Alexey Bataev286d1b92014-01-31 04:07:13 +00001358 if (Triple.getEnvironment() == llvm::Triple::Android) {
1359 // Add sse3 feature to comply with gcc on Android
1360 Features.push_back("+sse3");
1361 }
1362
Jim Grosbach82eee262013-11-16 00:53:35 +00001363 // Now add any that the user explicitly requested on the command line,
1364 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001365 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1366 ie = Args.filtered_end();
1367 it != ie; ++it) {
1368 StringRef Name = (*it)->getOption().getName();
1369 (*it)->claim();
1370
1371 // Skip over "-m".
1372 assert(Name.startswith("m") && "Invalid feature name.");
1373 Name = Name.substr(1);
1374
1375 bool IsNegative = Name.startswith("no-");
1376 if (IsNegative)
1377 Name = Name.substr(3);
1378
1379 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1380 }
1381}
1382
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001383void Clang::AddX86TargetArgs(const ArgList &Args,
1384 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001385 if (!Args.hasFlag(options::OPT_mred_zone,
1386 options::OPT_mno_red_zone,
1387 true) ||
1388 Args.hasArg(options::OPT_mkernel) ||
1389 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001390 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001391
Bob Wilson2616e2e2013-02-10 16:01:41 +00001392 // Default to avoid implicit floating-point for kernel/kext code, but allow
1393 // that to be overridden with -mno-soft-float.
1394 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1395 Args.hasArg(options::OPT_fapple_kext));
1396 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1397 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001398 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001399 options::OPT_mno_implicit_float)) {
1400 const Option &O = A->getOption();
1401 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1402 O.matches(options::OPT_msoft_float));
1403 }
1404 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001405 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001406}
1407
Matthew Curtise8f80a12012-12-06 17:49:03 +00001408static inline bool HasPICArg(const ArgList &Args) {
1409 return Args.hasArg(options::OPT_fPIC)
1410 || Args.hasArg(options::OPT_fpic);
1411}
1412
1413static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1414 return Args.getLastArg(options::OPT_G,
1415 options::OPT_G_EQ,
1416 options::OPT_msmall_data_threshold_EQ);
1417}
1418
1419static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1420 std::string value;
1421 if (HasPICArg(Args))
1422 value = "0";
1423 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1424 value = A->getValue();
1425 A->claim();
1426 }
1427 return value;
1428}
1429
Tony Linthicum76329bf2011-12-12 21:14:55 +00001430void Clang::AddHexagonTargetArgs(const ArgList &Args,
1431 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001432 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001433 CmdArgs.push_back("-mqdsp6-compat");
1434 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001435
Matthew Curtise8f80a12012-12-06 17:49:03 +00001436 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1437 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001438 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001439 CmdArgs.push_back(Args.MakeArgString(
1440 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001441 }
1442
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001443 if (!Args.hasArg(options::OPT_fno_short_enums))
1444 CmdArgs.push_back("-fshort-enums");
1445 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1446 CmdArgs.push_back ("-mllvm");
1447 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1448 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001449 CmdArgs.push_back ("-mllvm");
1450 CmdArgs.push_back ("-machine-sink-split=0");
1451}
1452
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001453static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1454 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001455 // Honor -mfpu=.
1456 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001457 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001458 else
1459 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001460
1461 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1462 Features.push_back("-fp-armv8");
1463 Features.push_back("-crypto");
1464 Features.push_back("-neon");
1465 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001466}
1467
1468static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001469 const ArgList &Args, ArgStringList &CmdArgs,
1470 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001471 std::vector<const char *> Features;
1472 switch (Triple.getArch()) {
1473 default:
1474 break;
1475 case llvm::Triple::mips:
1476 case llvm::Triple::mipsel:
1477 case llvm::Triple::mips64:
1478 case llvm::Triple::mips64el:
1479 getMIPSTargetFeatures(D, Args, Features);
1480 break;
1481
1482 case llvm::Triple::arm:
1483 case llvm::Triple::thumb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001484 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001485 break;
1486
1487 case llvm::Triple::ppc:
1488 case llvm::Triple::ppc64:
1489 case llvm::Triple::ppc64le:
1490 getPPCTargetFeatures(Args, Features);
1491 break;
1492 case llvm::Triple::sparc:
1493 getSparcTargetFeatures(Args, Features);
1494 break;
1495 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001496 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001497 getAArch64TargetFeatures(D, Args, Features);
1498 break;
1499 case llvm::Triple::x86:
1500 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001501 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001502 break;
1503 }
Rafael Espindola43964802013-08-21 17:34:32 +00001504
1505 // Find the last of each feature.
1506 llvm::StringMap<unsigned> LastOpt;
1507 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1508 const char *Name = Features[I];
1509 assert(Name[0] == '-' || Name[0] == '+');
1510 LastOpt[Name + 1] = I;
1511 }
1512
1513 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1514 // If this feature was overridden, ignore it.
1515 const char *Name = Features[I];
1516 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1517 assert(LastI != LastOpt.end());
1518 unsigned Last = LastI->second;
1519 if (Last != I)
1520 continue;
1521
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001522 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001523 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001524 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001525}
1526
Eric Christopher84fbdb42011-08-19 00:30:14 +00001527static bool
John McCall5fb5df92012-06-20 06:18:46 +00001528shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001529 const llvm::Triple &Triple) {
1530 // We use the zero-cost exception tables for Objective-C if the non-fragile
1531 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1532 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001533 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001534 return true;
1535
Bob Wilson83e723a2013-12-05 19:38:42 +00001536 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001537 return false;
1538
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001539 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001540 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001541 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001542}
1543
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001544namespace {
1545 struct ExceptionSettings {
1546 bool ExceptionsEnabled;
1547 bool ShouldUseExceptionTables;
1548 ExceptionSettings() : ExceptionsEnabled(false),
1549 ShouldUseExceptionTables(false) {}
1550 };
1551} // end anonymous namespace.
1552
Robert Lytton694f8842014-02-13 10:38:56 +00001553// exceptionSettings() exists to share the logic between -cc1 and linker invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001554static ExceptionSettings exceptionSettings(const ArgList &Args,
1555 const llvm::Triple &Triple) {
1556 ExceptionSettings ES;
1557
1558 // Are exceptions enabled by default?
1559 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1560
1561 // This keeps track of whether exceptions were explicitly turned on or off.
1562 bool DidHaveExplicitExceptionFlag = false;
1563
1564 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1565 options::OPT_fno_exceptions)) {
1566 if (A->getOption().matches(options::OPT_fexceptions))
1567 ES.ExceptionsEnabled = true;
1568 else
1569 ES.ExceptionsEnabled = false;
1570
1571 DidHaveExplicitExceptionFlag = true;
1572 }
1573
1574 // Exception tables and cleanups can be enabled with -fexceptions even if the
1575 // language itself doesn't support exceptions.
1576 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1577 ES.ShouldUseExceptionTables = true;
1578
1579 return ES;
1580}
1581
Anders Carlssone96ab552011-02-28 02:27:16 +00001582/// addExceptionArgs - Adds exception related arguments to the driver command
1583/// arguments. There's a master flag, -fexceptions and also language specific
1584/// flags to enable/disable C++ and Objective-C exceptions.
1585/// This makes it possible to for example disable C++ exceptions but enable
1586/// Objective-C exceptions.
1587static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1588 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001589 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001590 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001591 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001592 if (KernelOrKext) {
1593 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1594 // arguments now to avoid warnings about unused arguments.
1595 Args.ClaimAllArgs(options::OPT_fexceptions);
1596 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1597 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1598 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1599 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1600 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001601 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001602 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001603
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001604 // Gather the exception settings from the command line arguments.
1605 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001606
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001607 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1608 // is not necessarily sensible, but follows GCC.
1609 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001610 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001611 options::OPT_fno_objc_exceptions,
1612 true)) {
1613 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001614
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001615 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001616 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001617 }
1618
1619 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001620 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001621
Eric Christopher84fbdb42011-08-19 00:30:14 +00001622 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1623 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001624 options::OPT_fexceptions,
1625 options::OPT_fno_exceptions)) {
1626 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1627 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001628 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001629 CXXExceptionsEnabled = false;
1630 }
1631
1632 if (CXXExceptionsEnabled) {
1633 CmdArgs.push_back("-fcxx-exceptions");
1634
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001635 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001636 }
1637 }
1638
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001639 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001640 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001641}
1642
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001643static bool ShouldDisableAutolink(const ArgList &Args,
1644 const ToolChain &TC) {
1645 bool Default = true;
1646 if (TC.getTriple().isOSDarwin()) {
1647 // The native darwin assembler doesn't support the linker_option directives,
1648 // so we disable them if we think the .s file will be passed to it.
1649 Default = TC.useIntegratedAs();
1650 }
1651 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1652 Default);
1653}
1654
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001655static bool ShouldDisableCFI(const ArgList &Args,
1656 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001657 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001658 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001659 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001660 // we disable them if we think the .s file will be passed to it.
Rafael Espindola84b588b2013-03-18 18:10:27 +00001661 Default = TC.useIntegratedAs();
Rafael Espindolaf934f982011-05-17 16:26:17 +00001662 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001663 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
Eric Christopher45f2e712012-12-18 00:31:10 +00001664 options::OPT_fno_dwarf2_cfi_asm,
1665 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001666}
1667
Ted Kremenek62093662013-03-12 17:02:12 +00001668static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1669 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001670 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1671 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001672 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001673 return !UseDwarfDirectory;
1674}
1675
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001676/// \brief Check whether the given input tree contains any compilation actions.
1677static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001678 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001679 return true;
1680
1681 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1682 if (ContainsCompileAction(*it))
1683 return true;
1684
1685 return false;
1686}
1687
1688/// \brief Check if -relax-all should be passed to the internal assembler.
1689/// This is done by default when compiling non-assembler source with -O0.
1690static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1691 bool RelaxDefault = true;
1692
1693 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1694 RelaxDefault = A->getOption().matches(options::OPT_O0);
1695
1696 if (RelaxDefault) {
1697 RelaxDefault = false;
1698 for (ActionList::const_iterator it = C.getActions().begin(),
1699 ie = C.getActions().end(); it != ie; ++it) {
1700 if (ContainsCompileAction(*it)) {
1701 RelaxDefault = true;
1702 break;
1703 }
1704 }
1705 }
1706
1707 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1708 RelaxDefault);
1709}
1710
David Blaikie9260ed62013-07-25 21:19:01 +00001711static void CollectArgsForIntegratedAssembler(Compilation &C,
1712 const ArgList &Args,
1713 ArgStringList &CmdArgs,
1714 const Driver &D) {
1715 if (UseRelaxAll(C, Args))
1716 CmdArgs.push_back("-mrelax-all");
1717
David Peixottodfb66142013-11-14 22:52:58 +00001718 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001719 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001720 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1721 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1722 // arg after parsing the '-I' arg.
1723 bool TakeNextArg = false;
1724
David Blaikie9260ed62013-07-25 21:19:01 +00001725 // When using an integrated assembler, translate -Wa, and -Xassembler
1726 // options.
1727 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1728 options::OPT_Xassembler),
1729 ie = Args.filtered_end(); it != ie; ++it) {
1730 const Arg *A = *it;
1731 A->claim();
1732
1733 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1734 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001735 if (TakeNextArg) {
1736 CmdArgs.push_back(Value.data());
1737 TakeNextArg = false;
1738 continue;
1739 }
David Blaikie9260ed62013-07-25 21:19:01 +00001740
1741 if (Value == "-force_cpusubtype_ALL") {
1742 // Do nothing, this is the default and we don't support anything else.
1743 } else if (Value == "-L") {
1744 CmdArgs.push_back("-msave-temp-labels");
1745 } else if (Value == "--fatal-warnings") {
1746 CmdArgs.push_back("-mllvm");
1747 CmdArgs.push_back("-fatal-assembler-warnings");
1748 } else if (Value == "--noexecstack") {
1749 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001750 } else if (Value == "-compress-debug-sections" ||
1751 Value == "--compress-debug-sections") {
David Blaikie372d9502014-01-17 03:17:40 +00001752 D.Diag(diag::warn_missing_debug_compression);
David Peixottodfb66142013-11-14 22:52:58 +00001753 } else if (Value.startswith("-I")) {
1754 CmdArgs.push_back(Value.data());
1755 // We need to consume the next argument if the current arg is a plain
1756 // -I. The next arg will be the include directory.
1757 if (Value == "-I")
1758 TakeNextArg = true;
David Blaikie9260ed62013-07-25 21:19:01 +00001759 } else {
1760 D.Diag(diag::err_drv_unsupported_option_argument)
1761 << A->getOption().getName() << Value;
1762 }
1763 }
1764 }
1765}
1766
Renato Goline807c122014-01-31 11:47:28 +00001767// Until ARM libraries are build separately, we have them all in one library
1768static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
1769 if (TC.getArch() == llvm::Triple::arm)
1770 return "arm";
1771 else
1772 return TC.getArchName();
1773}
1774
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001775static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1776 // The runtimes are located in the OS-specific resource directory.
1777 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001778 const llvm::Triple &Triple = TC.getTriple();
1779 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1780 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1781 "freebsd" : TC.getOS();
1782 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001783 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001784}
1785
Renato Golinc4b49242014-02-13 10:01:16 +00001786// This adds the static libclang_rt.arch.a directly to the command line
1787// FIXME: Make sure we can also emit shared objects if they're requested
1788// and available, check for possible errors, etc.
1789static void addClangRTLinux(
1790 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001791 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
1792 llvm::sys::path::append(LibClangRT,
Renato Golinc4b49242014-02-13 10:01:16 +00001793 Twine("libclang_rt.") + getArchNameForCompilerRTLib(TC) + ".a");
1794
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001795 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001796 CmdArgs.push_back("-lgcc_s");
1797 if (TC.getDriver().CCCIsCXX())
1798 CmdArgs.push_back("-lgcc_eh");
1799}
1800
Alexey Samsonov7811d192014-02-20 13:57:37 +00001801static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001802 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1803 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1804 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001805 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001806 Args.hasArg(options::OPT_fcreate_profile) ||
1807 Args.hasArg(options::OPT_coverage)))
1808 return;
1809
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001810 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1811 llvm::sys::path::append(LibProfile,
Renato Goline807c122014-01-31 11:47:28 +00001812 Twine("libclang_rt.profile-") + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001813
1814 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1815}
1816
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001817static void addSanitizerRTLinkFlags(
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001818 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
Richard Smithf3e624c2013-03-23 00:30:08 +00001819 const StringRef Sanitizer, bool BeforeLibStdCXX,
1820 bool ExportSymbols = true) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001821 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1822 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1823 llvm::sys::path::append(LibSanitizer,
1824 (Twine("libclang_rt.") + Sanitizer + "-" +
1825 getArchNameForCompilerRTLib(TC) + ".a"));
Richard Smithcff3cde2013-03-20 23:49:07 +00001826
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001827 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1828 // etc.) so that the linker picks custom versions of the global 'operator
1829 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001830 // strategy of inserting it at the front of the link command. It also
1831 // needs to be forced to end up in the executable, so wrap it in
1832 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001833 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001834 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001835 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001836 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001837
1838 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1839 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1840
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001841 CmdArgs.push_back("-lpthread");
Evgeniy Stepanov758b5072013-05-24 14:28:03 +00001842 CmdArgs.push_back("-lrt");
Evgeniy Stepanov4ae68462013-10-29 19:48:47 +00001843 CmdArgs.push_back("-lm");
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001844 // There's no libdl on FreeBSD.
1845 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1846 CmdArgs.push_back("-ldl");
Richard Smithf3e624c2013-03-23 00:30:08 +00001847
1848 // If possible, use a dynamic symbols file to export the symbols from the
1849 // runtime library. If we can't do so, use -export-dynamic instead to export
1850 // all symbols from the binary.
1851 if (ExportSymbols) {
1852 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1853 CmdArgs.push_back(
1854 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1855 else
1856 CmdArgs.push_back("-export-dynamic");
1857 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001858}
1859
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001860/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1861/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001862static void addAsanRT(const ToolChain &TC, const ArgList &Args,
1863 ArgStringList &CmdArgs) {
Nick Lewycky609dd662013-10-11 03:33:53 +00001864 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001865 SmallString<128> LibAsan = getCompilerRTLibDir(TC);
1866 llvm::sys::path::append(LibAsan,
1867 (Twine("libclang_rt.asan-") +
1868 getArchNameForCompilerRTLib(TC) + "-android.so"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001869 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001870 } else {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001871 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001872 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001873 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001874}
1875
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001876/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1877/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001878static void addTsanRT(const ToolChain &TC, const ArgList &Args,
1879 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001880 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001881 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001882}
1883
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001884/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1885/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001886static void addMsanRT(const ToolChain &TC, const ArgList &Args,
1887 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001888 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001889 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001890}
1891
1892/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1893/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001894static void addLsanRT(const ToolChain &TC, const ArgList &Args,
1895 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001896 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001897 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001898}
1899
Richard Smithe30752c2012-10-09 19:52:38 +00001900/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1901/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001902static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
1903 ArgStringList &CmdArgs, bool IsCXX,
1904 bool HasOtherSanitizerRt) {
Nick Lewycky24921692013-10-19 00:27:23 +00001905 // Need a copy of sanitizer_common. This could come from another sanitizer
1906 // runtime; if we're not including one, include our own copy.
1907 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001908 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001909
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001910 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001911
1912 // Only include the bits of the runtime which need a C++ ABI library if
1913 // we're linking in C++ mode.
1914 if (IsCXX)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001915 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false);
Richard Smithe30752c2012-10-09 19:52:38 +00001916}
1917
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001918static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
1919 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00001920 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001921 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
1922}
1923
1924// Should be called before we add C++ ABI library.
1925static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
1926 ArgStringList &CmdArgs) {
1927 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
1928 const Driver &D = TC.getDriver();
1929 if (Sanitize.needsUbsanRt())
1930 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
1931 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
1932 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
1933 if (Sanitize.needsAsanRt())
1934 addAsanRT(TC, Args, CmdArgs);
1935 if (Sanitize.needsTsanRt())
1936 addTsanRT(TC, Args, CmdArgs);
1937 if (Sanitize.needsMsanRt())
1938 addMsanRT(TC, Args, CmdArgs);
1939 if (Sanitize.needsLsanRt())
1940 addLsanRT(TC, Args, CmdArgs);
1941 if (Sanitize.needsDfsanRt())
1942 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00001943}
1944
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001945static bool shouldUseFramePointerForTarget(const ArgList &Args,
1946 const llvm::Triple &Triple) {
1947 switch (Triple.getArch()) {
1948 // Don't use a frame pointer on linux if optimizing for certain targets.
1949 case llvm::Triple::mips64:
1950 case llvm::Triple::mips64el:
1951 case llvm::Triple::mips:
1952 case llvm::Triple::mipsel:
1953 case llvm::Triple::systemz:
1954 case llvm::Triple::x86:
1955 case llvm::Triple::x86_64:
1956 if (Triple.isOSLinux())
1957 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1958 if (!A->getOption().matches(options::OPT_O0))
1959 return false;
1960 return true;
1961 case llvm::Triple::xcore:
1962 return false;
1963 default:
1964 return true;
1965 }
1966}
1967
Rafael Espindola224dd632011-12-14 21:02:23 +00001968static bool shouldUseFramePointer(const ArgList &Args,
1969 const llvm::Triple &Triple) {
1970 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1971 options::OPT_fomit_frame_pointer))
1972 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1973
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001974 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00001975}
1976
Eric Christopherb7d97e92013-04-03 01:58:53 +00001977static bool shouldUseLeafFramePointer(const ArgList &Args,
1978 const llvm::Triple &Triple) {
1979 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1980 options::OPT_momit_leaf_frame_pointer))
1981 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1982
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001983 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00001984}
1985
Rafael Espindolac7367ff2013-08-10 01:40:10 +00001986/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00001987static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00001988 SmallString<128> cwd;
1989 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00001990 CmdArgs.push_back("-fdebug-compilation-dir");
1991 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00001992 }
1993}
1994
Eric Christopherd3804002013-02-22 20:12:52 +00001995static const char *SplitDebugName(const ArgList &Args,
1996 const InputInfoList &Inputs) {
1997 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1998 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1999 SmallString<128> T(FinalOutput->getValue());
2000 llvm::sys::path::replace_extension(T, "dwo");
2001 return Args.MakeArgString(T);
2002 } else {
2003 // Use the compilation dir.
2004 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2005 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2006 llvm::sys::path::replace_extension(F, "dwo");
2007 T += F;
2008 return Args.MakeArgString(F);
2009 }
2010}
2011
2012static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2013 const Tool &T, const JobAction &JA,
2014 const ArgList &Args, const InputInfo &Output,
2015 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002016 ArgStringList ExtractArgs;
2017 ExtractArgs.push_back("--extract-dwo");
2018
2019 ArgStringList StripArgs;
2020 StripArgs.push_back("--strip-dwo");
2021
2022 // Grabbing the output of the earlier compile step.
2023 StripArgs.push_back(Output.getFilename());
2024 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002025 ExtractArgs.push_back(OutFile);
2026
2027 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002028 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002029
2030 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002031 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002032
2033 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002034 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002035}
2036
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002037static bool isOptimizationLevelFast(const ArgList &Args) {
2038 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2039 if (A->getOption().matches(options::OPT_Ofast))
2040 return true;
2041 return false;
2042}
2043
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002044/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2045static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2046 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002047 if (A->getOption().matches(options::OPT_O4) ||
2048 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002049 return true;
2050
2051 if (A->getOption().matches(options::OPT_O0))
2052 return false;
2053
2054 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2055
Rafael Espindola91780de2013-08-26 14:05:41 +00002056 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002057 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002058 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002059 return true;
2060
2061 // Don't vectorize -Oz.
2062 if (S == "z")
2063 return false;
2064
2065 unsigned OptLevel = 0;
2066 if (S.getAsInteger(10, OptLevel))
2067 return false;
2068
2069 return OptLevel > 1;
2070 }
2071
2072 return false;
2073}
2074
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002075/// Add -x lang to \p CmdArgs for \p Input.
2076static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2077 ArgStringList &CmdArgs) {
2078 // When using -verify-pch, we don't want to provide the type
2079 // 'precompiled-header' if it was inferred from the file extension
2080 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2081 return;
2082
2083 CmdArgs.push_back("-x");
2084 if (Args.hasArg(options::OPT_rewrite_objc))
2085 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2086 else
2087 CmdArgs.push_back(types::getTypeName(Input.getType()));
2088}
2089
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002090void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002091 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002092 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002093 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002094 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002095 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2096 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002097 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002098 ArgStringList CmdArgs;
2099
Daniel Dunbare521a892009-03-31 20:53:55 +00002100 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2101
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002102 // Invoke ourselves in -cc1 mode.
2103 //
2104 // FIXME: Implement custom jobs for internal actions.
2105 CmdArgs.push_back("-cc1");
2106
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002107 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002108 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002109 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002110 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002111
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002112 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002113 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002114
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002115 if (isa<AnalyzeJobAction>(JA)) {
2116 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2117 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002118 } else if (isa<MigrateJobAction>(JA)) {
2119 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002120 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002121 if (Output.getType() == types::TY_Dependencies)
2122 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002123 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002124 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002125 if (Args.hasArg(options::OPT_rewrite_objc) &&
2126 !Args.hasArg(options::OPT_g_Group))
2127 CmdArgs.push_back("-P");
2128 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002129 } else if (isa<AssembleJobAction>(JA)) {
2130 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002131
David Blaikie9260ed62013-07-25 21:19:01 +00002132 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002133
2134 // Also ignore explicit -force_cpusubtype_ALL option.
2135 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002136 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002137 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002138 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002139
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002140 if (JA.getType() == types::TY_Nothing)
2141 CmdArgs.push_back("-fsyntax-only");
2142 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002143 CmdArgs.push_back("-emit-pch");
2144 else
2145 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002146 } else if (isa<VerifyPCHJobAction>(JA)) {
2147 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002148 } else {
2149 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002150
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002151 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002152 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002153 } else if (JA.getType() == types::TY_LLVM_IR ||
2154 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002155 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002156 } else if (JA.getType() == types::TY_LLVM_BC ||
2157 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002158 CmdArgs.push_back("-emit-llvm-bc");
2159 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002160 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002161 } else if (JA.getType() == types::TY_AST) {
2162 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002163 } else if (JA.getType() == types::TY_ModuleFile) {
2164 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002165 } else if (JA.getType() == types::TY_RewrittenObjC) {
2166 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002167 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002168 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2169 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002170 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002171 } else {
2172 assert(JA.getType() == types::TY_PP_Asm &&
2173 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002174 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002175 }
2176
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002177 // The make clang go fast button.
2178 CmdArgs.push_back("-disable-free");
2179
John McCallbb79b5f2010-02-13 03:50:24 +00002180 // Disable the verification pass in -asserts builds.
2181#ifdef NDEBUG
2182 CmdArgs.push_back("-disable-llvm-verifier");
2183#endif
2184
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002185 // Set the main file name, so that debug info works even with
2186 // -save-temps.
2187 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002188 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002189
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002190 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002191 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002192 if (Args.hasArg(options::OPT_static))
2193 CmdArgs.push_back("-static-define");
2194
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002195 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002196 // Enable region store model by default.
2197 CmdArgs.push_back("-analyzer-store=region");
2198
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002199 // Treat blocks as analysis entry points.
2200 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2201
Ted Kremenek49c79792011-03-24 00:28:47 +00002202 CmdArgs.push_back("-analyzer-eagerly-assume");
2203
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002204 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002205 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002206 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002207
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002208 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2209 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002210
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002211 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002212 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002213
2214 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002215
Jordan Rose10ad0812013-04-05 17:55:07 +00002216 if (types::isCXX(Inputs[0].getType()))
2217 CmdArgs.push_back("-analyzer-checker=cplusplus");
2218
Ted Kremenek37e96522012-01-26 02:27:38 +00002219 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00002220 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2221 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2222 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2223 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2224 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2225 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002226 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002227
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002228 // Set the output format. The default is plist, for (lame) historical
2229 // reasons.
2230 CmdArgs.push_back("-analyzer-output");
2231 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002232 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002233 else
2234 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002235
Ted Kremenekfe449a22010-03-22 22:32:05 +00002236 // Disable the presentation of standard compiler warnings when
2237 // using --analyze. We only want to show static analyzer diagnostics
2238 // or frontend errors.
2239 CmdArgs.push_back("-w");
2240
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002241 // Add -Xanalyzer arguments when running as analyzer.
2242 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002243 }
2244
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002245 CheckCodeGenerationOptions(D, Args);
2246
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002247 bool PIE = getToolChain().isPIEDefault();
2248 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002249 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002250
Alexey Bataev40e75222014-01-28 06:30:35 +00002251 // Android-specific defaults for PIC/PIE
2252 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2253 switch (getToolChain().getTriple().getArch()) {
2254 case llvm::Triple::arm:
2255 case llvm::Triple::thumb:
2256 case llvm::Triple::mips:
2257 case llvm::Triple::mipsel:
2258 case llvm::Triple::mips64:
2259 case llvm::Triple::mips64el:
2260 PIC = true; // "-fpic"
2261 break;
2262
2263 case llvm::Triple::x86:
2264 case llvm::Triple::x86_64:
2265 PIC = true; // "-fPIC"
2266 IsPICLevelTwo = true;
2267 break;
2268
2269 default:
2270 break;
2271 }
2272 }
2273
Alexey Samsonov090301e2013-04-09 12:28:19 +00002274 // For the PIC and PIE flag options, this logic is different from the
2275 // legacy logic in very old versions of GCC, as that logic was just
2276 // a bug no one had ever fixed. This logic is both more rational and
2277 // consistent with GCC's new logic now that the bugs are fixed. The last
2278 // argument relating to either PIC or PIE wins, and no other argument is
2279 // used. If the last argument is any flavor of the '-fno-...' arguments,
2280 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2281 // at the same level.
2282 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2283 options::OPT_fpic, options::OPT_fno_pic,
2284 options::OPT_fPIE, options::OPT_fno_PIE,
2285 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002286 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2287 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002288 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002289 if (LastPICArg) {
2290 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002291 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2292 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2293 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2294 PIC = PIE || O.matches(options::OPT_fPIC) ||
2295 O.matches(options::OPT_fpic);
2296 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2297 O.matches(options::OPT_fPIC);
2298 } else {
2299 PIE = PIC = false;
2300 }
2301 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002302 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002303
Nick Lewycky609dd662013-10-11 03:33:53 +00002304 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002305 // specified while enabling PIC enabled level 1 PIC, just force it back to
2306 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2307 // informal testing).
2308 if (PIC && getToolChain().getTriple().isOSDarwin())
2309 IsPICLevelTwo |= getToolChain().isPICDefault();
2310
Chandler Carruthc0c04552012-04-08 16:40:35 +00002311 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2312 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002313 llvm::Triple Triple(TripleStr);
Eric Christopher8d56caa2013-02-18 01:16:37 +00002314 if (KernelOrKext &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002315 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002316 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002317 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002318 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002319
Chandler Carruth76a943b2012-11-19 03:52:03 +00002320 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2321 // This is a very special mode. It trumps the other modes, almost no one
2322 // uses it, and it isn't even valid on any OS but Darwin.
2323 if (!getToolChain().getTriple().isOSDarwin())
2324 D.Diag(diag::err_drv_unsupported_opt_for_target)
2325 << A->getSpelling() << getToolChain().getTriple().str();
2326
2327 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2328
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002329 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002330 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002331
Chandler Carruth76a943b2012-11-19 03:52:03 +00002332 // Only a forced PIC mode can cause the actual compile to have PIC defines
2333 // etc., no flags are sufficient. This behavior was selected to closely
2334 // match that of llvm-gcc and Apple GCC before that.
2335 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2336 CmdArgs.push_back("-pic-level");
2337 CmdArgs.push_back("2");
2338 }
2339 } else {
2340 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2341 // handled in Clang's IRGen by the -pie-level flag.
2342 CmdArgs.push_back("-mrelocation-model");
2343 CmdArgs.push_back(PIC ? "pic" : "static");
2344
2345 if (PIC) {
2346 CmdArgs.push_back("-pic-level");
2347 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2348 if (PIE) {
2349 CmdArgs.push_back("-pie-level");
2350 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2351 }
2352 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002353 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002354
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002355 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2356 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002357 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002358
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002359 // LLVM Code Generator Options.
2360
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002361 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2362 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002363 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002364 }
2365
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002366 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2367 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002368 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002369 D.Diag(diag::err_drv_unsupported_opt_for_target)
2370 << A->getSpelling() << getToolChain().getTriple().str();
2371 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2372 CmdArgs.push_back("-fpcc-struct-return");
2373 } else {
2374 assert(A->getOption().matches(options::OPT_freg_struct_return));
2375 CmdArgs.push_back("-freg-struct-return");
2376 }
2377 }
2378
Roman Divacky65b88cd2011-03-01 17:40:53 +00002379 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2380 CmdArgs.push_back("-mrtd");
2381
Rafael Espindola224dd632011-12-14 21:02:23 +00002382 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002383 CmdArgs.push_back("-mdisable-fp-elim");
2384 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2385 options::OPT_fno_zero_initialized_in_bss))
2386 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002387
2388 bool OFastEnabled = isOptimizationLevelFast(Args);
2389 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2390 // enabled. This alias option is being used to simplify the hasFlag logic.
2391 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2392 options::OPT_fstrict_aliasing;
2393 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Rafael Espindola8f41aee2013-11-17 22:42:24 +00002394 options::OPT_fno_strict_aliasing, true))
Dan Gohman10169b92010-10-14 22:36:56 +00002395 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002396 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2397 options::OPT_fno_struct_path_tbaa))
2398 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002399 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2400 false))
2401 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002402 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2403 options::OPT_fno_optimize_sibling_calls))
2404 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002405
Eric Christopher006208c2013-04-04 06:29:47 +00002406 // Handle segmented stacks.
2407 if (Args.hasArg(options::OPT_fsplit_stack))
2408 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002409
2410 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2411 // This alias option is being used to simplify the getLastArg logic.
2412 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2413 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002414
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002415 // Handle various floating point optimization flags, mapping them to the
2416 // appropriate LLVM code generation flags. The pattern for all of these is to
2417 // default off the codegen optimizations, and if any flag enables them and no
2418 // flag disables them after the flag enabling them, enable the codegen
2419 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002420 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002421 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002422 options::OPT_ffinite_math_only,
2423 options::OPT_fno_finite_math_only,
2424 options::OPT_fhonor_infinities,
2425 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002426 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2427 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002428 A->getOption().getID() != options::OPT_fhonor_infinities)
2429 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002430 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002431 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002432 options::OPT_ffinite_math_only,
2433 options::OPT_fno_finite_math_only,
2434 options::OPT_fhonor_nans,
2435 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002436 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2437 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002438 A->getOption().getID() != options::OPT_fhonor_nans)
2439 CmdArgs.push_back("-menable-no-nans");
2440
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002441 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2442 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002443 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002444 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002445 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002446 options::OPT_fno_math_errno)) {
2447 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2448 // However, turning *off* -ffast_math merely restores the toolchain default
2449 // (which may be false).
2450 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2451 A->getOption().getID() == options::OPT_ffast_math ||
2452 A->getOption().getID() == options::OPT_Ofast)
2453 MathErrno = false;
2454 else if (A->getOption().getID() == options::OPT_fmath_errno)
2455 MathErrno = true;
2456 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002457 if (MathErrno)
2458 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002459
2460 // There are several flags which require disabling very specific
2461 // optimizations. Any of these being disabled forces us to turn off the
2462 // entire set of LLVM optimizations, so collect them through all the flag
2463 // madness.
2464 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002465 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002466 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002467 options::OPT_funsafe_math_optimizations,
2468 options::OPT_fno_unsafe_math_optimizations,
2469 options::OPT_fassociative_math,
2470 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002471 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2472 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002473 A->getOption().getID() != options::OPT_fno_associative_math)
2474 AssociativeMath = true;
2475 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002476 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002477 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002478 options::OPT_funsafe_math_optimizations,
2479 options::OPT_fno_unsafe_math_optimizations,
2480 options::OPT_freciprocal_math,
2481 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002482 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2483 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002484 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2485 ReciprocalMath = true;
2486 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002487 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002488 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002489 options::OPT_funsafe_math_optimizations,
2490 options::OPT_fno_unsafe_math_optimizations,
2491 options::OPT_fsigned_zeros,
2492 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002493 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2494 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002495 A->getOption().getID() != options::OPT_fsigned_zeros)
2496 SignedZeros = false;
2497 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002498 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002499 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002500 options::OPT_funsafe_math_optimizations,
2501 options::OPT_fno_unsafe_math_optimizations,
2502 options::OPT_ftrapping_math,
2503 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002504 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2505 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002506 A->getOption().getID() != options::OPT_ftrapping_math)
2507 TrappingMath = false;
2508 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2509 !TrappingMath)
2510 CmdArgs.push_back("-menable-unsafe-fp-math");
2511
Lang Hamesaa53b932012-07-06 00:59:19 +00002512
2513 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002514 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002515 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002516 options::OPT_ffp_contract)) {
2517 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002518 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002519 if (Val == "fast" || Val == "on" || Val == "off") {
2520 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2521 } else {
2522 D.Diag(diag::err_drv_unsupported_option_argument)
2523 << A->getOption().getName() << Val;
2524 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002525 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2526 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002527 // If fast-math is set then set the fp-contract mode to fast.
2528 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2529 }
2530 }
2531
Bob Wilson6a039162012-07-19 03:52:53 +00002532 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2533 // and if we find them, tell the frontend to provide the appropriate
2534 // preprocessor macros. This is distinct from enabling any optimizations as
2535 // these options induce language changes which must survive serialization
2536 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002537 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2538 options::OPT_fno_fast_math))
2539 if (!A->getOption().matches(options::OPT_fno_fast_math))
2540 CmdArgs.push_back("-ffast-math");
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002541 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2542 if (A->getOption().matches(options::OPT_ffinite_math_only))
2543 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002544
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002545 // Decide whether to use verbose asm. Verbose assembly is the default on
2546 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002547 bool IsIntegratedAssemblerDefault =
2548 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002549 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002550 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002551 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002552 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002553
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002554 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002555 IsIntegratedAssemblerDefault))
2556 CmdArgs.push_back("-no-integrated-as");
2557
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002558 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2559 CmdArgs.push_back("-mdebug-pass");
2560 CmdArgs.push_back("Structure");
2561 }
2562 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2563 CmdArgs.push_back("-mdebug-pass");
2564 CmdArgs.push_back("Arguments");
2565 }
2566
John McCall8517abc2010-02-19 02:45:38 +00002567 // Enable -mconstructor-aliases except on darwin, where we have to
2568 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002569 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002570 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002571
John McCall7ef5cb32011-03-18 02:56:14 +00002572 // Darwin's kernel doesn't support guard variables; just die if we
2573 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002574 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002575 CmdArgs.push_back("-fforbid-guard-variables");
2576
Douglas Gregordbe39272011-02-01 15:15:22 +00002577 if (Args.hasArg(options::OPT_mms_bitfields)) {
2578 CmdArgs.push_back("-mms-bitfields");
2579 }
John McCall8517abc2010-02-19 02:45:38 +00002580
Daniel Dunbar306945d2009-09-16 06:17:29 +00002581 // This is a coarse approximation of what llvm-gcc actually does, both
2582 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2583 // complicated ways.
2584 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002585 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2586 options::OPT_fno_asynchronous_unwind_tables,
2587 (getToolChain().IsUnwindTablesDefault() ||
2588 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2589 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002590 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2591 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002592 CmdArgs.push_back("-munwind-tables");
2593
Chandler Carruth05fb5852012-11-21 23:40:23 +00002594 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002595
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002596 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2597 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002598 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002599 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002600
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002601 // FIXME: Handle -mtune=.
2602 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002603
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002604 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002605 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002606 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002607 }
2608
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002609 // Add the target cpu
2610 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2611 llvm::Triple ETriple(ETripleStr);
2612 std::string CPU = getCPUName(Args, ETriple);
2613 if (!CPU.empty()) {
2614 CmdArgs.push_back("-target-cpu");
2615 CmdArgs.push_back(Args.MakeArgString(CPU));
2616 }
2617
Rafael Espindolaeb265472013-08-21 21:59:03 +00002618 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2619 CmdArgs.push_back("-mfpmath");
2620 CmdArgs.push_back(A->getValue());
2621 }
2622
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002623 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002624 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002625
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002626 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002627 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002628 default:
2629 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002630
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002631 case llvm::Triple::arm:
2632 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002633 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002634 break;
2635
Eric Christopher0b26a612010-03-02 02:41:08 +00002636 case llvm::Triple::mips:
2637 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002638 case llvm::Triple::mips64:
2639 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002640 AddMIPSTargetArgs(Args, CmdArgs);
2641 break;
2642
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002643 case llvm::Triple::sparc:
2644 AddSparcTargetArgs(Args, CmdArgs);
2645 break;
2646
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002647 case llvm::Triple::x86:
2648 case llvm::Triple::x86_64:
2649 AddX86TargetArgs(Args, CmdArgs);
2650 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002651
2652 case llvm::Triple::hexagon:
2653 AddHexagonTargetArgs(Args, CmdArgs);
2654 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002655 }
2656
Hans Wennborg75958c42013-08-08 00:17:41 +00002657 // Add clang-cl arguments.
2658 if (getToolChain().getDriver().IsCLMode())
2659 AddClangCLArgs(Args, CmdArgs);
2660
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002661 // Pass the linker version in use.
2662 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2663 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002664 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002665 }
2666
Eric Christopherb7d97e92013-04-03 01:58:53 +00002667 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002668 CmdArgs.push_back("-momit-leaf-frame-pointer");
2669
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002670 // Explicitly error on some things we know we don't support and can't just
2671 // ignore.
2672 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002673 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2674 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002675 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002676 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002677 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002678 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2679 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002680 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002681 << Unsupported->getOption().getName();
2682 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002683 }
2684
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002685 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002686 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002687 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002688 CmdArgs.push_back("-header-include-file");
2689 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2690 D.CCPrintHeadersFilename : "-");
2691 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002692 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002693 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002694
Chad Rosierbe10f982011-08-02 17:58:04 +00002695 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002696 CmdArgs.push_back("-diagnostic-log-file");
2697 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2698 D.CCLogDiagnosticsFilename : "-");
2699 }
2700
Manman Ren17bdb0f2013-11-20 20:22:14 +00002701 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2702 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002703 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002704 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikie29559b12014-03-11 21:05:26 +00002705 if (A->getOption().matches(options::OPT_gline_tables_only) ||
2706 A->getOption().matches(options::OPT_gmlt)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002707 // FIXME: we should support specifying dwarf version with
2708 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002709 CmdArgs.push_back("-gline-tables-only");
Adrian Prantl549c5142014-02-17 17:40:52 +00002710 // Default is dwarf-2 for darwin.
2711 if (getToolChain().getTriple().isOSDarwin())
2712 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002713 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002714 CmdArgs.push_back("-gdwarf-2");
2715 else if (A->getOption().matches(options::OPT_gdwarf_3))
2716 CmdArgs.push_back("-gdwarf-3");
2717 else if (A->getOption().matches(options::OPT_gdwarf_4))
2718 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002719 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002720 !A->getOption().matches(options::OPT_ggdb0)) {
2721 // Default is dwarf-2 for darwin.
2722 if (getToolChain().getTriple().isOSDarwin())
2723 CmdArgs.push_back("-gdwarf-2");
2724 else
2725 CmdArgs.push_back("-g");
2726 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002727 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002728
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002729 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2730 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002731 if (Args.hasArg(options::OPT_gcolumn_info))
2732 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002733
Eric Christopher138c32b2013-09-13 22:37:55 +00002734 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002735 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2736 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002737 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002738 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002739 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002740 CmdArgs.push_back("-g");
2741 CmdArgs.push_back("-backend-option");
2742 CmdArgs.push_back("-split-dwarf=Enable");
2743 }
2744
Eric Christopher138c32b2013-09-13 22:37:55 +00002745 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2746 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2747 CmdArgs.push_back("-backend-option");
2748 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2749 }
Eric Christophereec89c22013-06-18 00:03:50 +00002750
Eric Christopher0d403d22014-02-14 01:27:03 +00002751 // -gdwarf-aranges turns on the emission of the aranges section in the
2752 // backend.
2753 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2754 CmdArgs.push_back("-backend-option");
2755 CmdArgs.push_back("-generate-arange-section");
2756 }
2757
David Blaikief36d9ba2014-01-27 18:52:43 +00002758 if (Args.hasFlag(options::OPT_fdebug_types_section,
2759 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002760 CmdArgs.push_back("-backend-option");
2761 CmdArgs.push_back("-generate-type-units");
2762 }
Eric Christophereec89c22013-06-18 00:03:50 +00002763
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002764 if (Args.hasFlag(options::OPT_ffunction_sections,
2765 options::OPT_fno_function_sections, false)) {
2766 CmdArgs.push_back("-ffunction-sections");
2767 }
2768
2769 if (Args.hasFlag(options::OPT_fdata_sections,
2770 options::OPT_fno_data_sections, false)) {
2771 CmdArgs.push_back("-fdata-sections");
2772 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002773
Chris Lattner3c77a352010-06-22 00:03:40 +00002774 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2775
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002776 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2777 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2778 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2779 D.Diag(diag::err_drv_argument_not_allowed_with)
2780 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2781
2782 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2783
2784 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2785 A->render(Args, CmdArgs);
2786 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2787 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
2788
Nick Lewycky207bce32011-04-21 23:44:07 +00002789 if (Args.hasArg(options::OPT_ftest_coverage) ||
2790 Args.hasArg(options::OPT_coverage))
2791 CmdArgs.push_back("-femit-coverage-notes");
2792 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2793 Args.hasArg(options::OPT_coverage))
2794 CmdArgs.push_back("-femit-coverage-data");
2795
Nick Lewycky480cb992011-05-04 20:46:58 +00002796 if (C.getArgs().hasArg(options::OPT_c) ||
2797 C.getArgs().hasArg(options::OPT_S)) {
2798 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002799 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00002800 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00002801 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002802 SmallString<128> Pwd;
2803 if (!llvm::sys::fs::current_path(Pwd)) {
2804 llvm::sys::path::append(Pwd, CoverageFilename.str());
2805 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00002806 }
2807 }
Eric Christophere30f61c2013-02-22 00:24:40 +00002808 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002809 }
2810 }
2811
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002812 // Pass options for controlling the default header search paths.
2813 if (Args.hasArg(options::OPT_nostdinc)) {
2814 CmdArgs.push_back("-nostdsysteminc");
2815 CmdArgs.push_back("-nobuiltininc");
2816 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002817 if (Args.hasArg(options::OPT_nostdlibinc))
2818 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002819 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2820 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2821 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002822
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002823 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002824 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002825 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002826
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002827 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2828
Ted Kremenekf7639e12012-03-06 20:06:33 +00002829 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00002830 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002831 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002832 options::OPT_ccc_arcmt_modify,
2833 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002834 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002835 switch (A->getOption().getID()) {
2836 default:
2837 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002838 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002839 CmdArgs.push_back("-arcmt-check");
2840 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002841 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002842 CmdArgs.push_back("-arcmt-modify");
2843 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002844 case options::OPT_ccc_arcmt_migrate:
2845 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002846 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002847 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002848
2849 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2850 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002851 break;
John McCalld70fb982011-06-15 23:25:17 +00002852 }
2853 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00002854 } else {
2855 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2856 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2857 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00002858 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002859
Ted Kremenekf7639e12012-03-06 20:06:33 +00002860 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2861 if (ARCMTEnabled) {
2862 D.Diag(diag::err_drv_argument_not_allowed_with)
2863 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2864 }
2865 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002866 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002867
2868 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002869 options::OPT_objcmt_migrate_subscripting,
2870 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002871 // None specified, means enable them all.
2872 CmdArgs.push_back("-objcmt-migrate-literals");
2873 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002874 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002875 } else {
2876 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2877 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002878 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002879 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00002880 } else {
2881 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2882 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2883 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2884 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2885 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2886 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2887 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2888 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2889 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2890 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2891 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2892 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2893 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00002894 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00002895 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002896 }
2897
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002898 // Add preprocessing options like -I, -D, etc. if we are using the
2899 // preprocessor.
2900 //
2901 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002902 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00002903 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002904
Rafael Espindolaa7431922011-07-21 23:40:37 +00002905 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2906 // that "The compiler can only warn and ignore the option if not recognized".
2907 // When building with ccache, it will pass -D options to clang even on
2908 // preprocessed inputs and configure concludes that -fPIC is not supported.
2909 Args.ClaimAllArgs(options::OPT_D);
2910
Alp Toker7874bdc2013-11-15 20:40:58 +00002911 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00002912 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2913 if (A->getOption().matches(options::OPT_O4)) {
2914 CmdArgs.push_back("-O3");
2915 D.Diag(diag::warn_O4_is_O3);
2916 } else {
2917 A->render(Args, CmdArgs);
2918 }
2919 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002920
Chad Rosier86b82082012-12-12 20:06:31 +00002921 // Don't warn about unused -flto. This can happen when we're preprocessing or
2922 // precompiling.
2923 Args.ClaimAllArgs(options::OPT_flto);
2924
Daniel Dunbar945577c2009-10-29 02:24:45 +00002925 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002926 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2927 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002928 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002929 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002930
2931 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00002932 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002933 //
2934 // If a std is supplied, only add -trigraphs if it follows the
2935 // option.
2936 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2937 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002938 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002939 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002940 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002941 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002942 else
2943 Std->render(Args, CmdArgs);
2944
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002945 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2946 options::OPT_trigraphs))
2947 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002948 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002949 } else {
2950 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002951 //
2952 // FIXME: Clang doesn't correctly handle -std= when the input language
2953 // doesn't match. For the time being just ignore this for C++ inputs;
2954 // eventually we want to do all the standard defaulting here instead of
2955 // splitting it between the driver and clang -cc1.
2956 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002957 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2958 "-std=", /*Joined=*/true);
2959 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2960 CmdArgs.push_back("-std=c++11");
2961
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002962 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002963 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002964
Richard Smith282b4492013-09-04 22:50:31 +00002965 // GCC's behavior for -Wwrite-strings is a bit strange:
2966 // * In C, this "warning flag" changes the types of string literals from
2967 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2968 // for the discarded qualifier.
2969 // * In C++, this is just a normal warning flag.
2970 //
2971 // Implementing this warning correctly in C is hard, so we follow GCC's
2972 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2973 // a non-const char* in C, rather than using this crude hack.
2974 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00002975 // FIXME: This should behave just like a warning flag, and thus should also
2976 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
2977 Arg *WriteStrings =
2978 Args.getLastArg(options::OPT_Wwrite_strings,
2979 options::OPT_Wno_write_strings, options::OPT_w);
2980 if (WriteStrings &&
2981 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00002982 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00002983 }
2984
Chandler Carruth61fbf622011-04-23 09:27:53 +00002985 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002986 // during C++ compilation, which it is by default. GCC keeps this define even
2987 // in the presence of '-w', match this behavior bug-for-bug.
2988 if (types::isCXX(InputType) &&
2989 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2990 true)) {
2991 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002992 }
2993
Chandler Carruthe0391482010-05-22 02:21:53 +00002994 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2995 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2996 if (Asm->getOption().matches(options::OPT_fasm))
2997 CmdArgs.push_back("-fgnu-keywords");
2998 else
2999 CmdArgs.push_back("-fno-gnu-keywords");
3000 }
3001
Rafael Espindola4cfa7972011-05-02 17:43:32 +00003002 if (ShouldDisableCFI(Args, getToolChain()))
3003 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00003004
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003005 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3006 CmdArgs.push_back("-fno-dwarf-directory-asm");
3007
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003008 if (ShouldDisableAutolink(Args, getToolChain()))
3009 CmdArgs.push_back("-fno-autolink");
3010
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003011 // Add in -fdebug-compilation-dir if necessary.
3012 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003013
Richard Smith9a568822011-11-21 19:36:32 +00003014 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3015 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003016 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003017 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003018 }
3019
Richard Smith79c927b2013-11-06 19:31:51 +00003020 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3021 CmdArgs.push_back("-foperator-arrow-depth");
3022 CmdArgs.push_back(A->getValue());
3023 }
3024
Richard Smith9a568822011-11-21 19:36:32 +00003025 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3026 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003027 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003028 }
3029
Richard Smitha3d3bd22013-05-08 02:12:03 +00003030 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3031 CmdArgs.push_back("-fconstexpr-steps");
3032 CmdArgs.push_back(A->getValue());
3033 }
3034
Richard Smithb3a14522013-02-22 01:59:51 +00003035 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3036 CmdArgs.push_back("-fbracket-depth");
3037 CmdArgs.push_back(A->getValue());
3038 }
3039
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003040 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3041 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003042 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003043 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003044 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3045 } else
3046 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003047 }
3048
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003049
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003050 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003051 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003052
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003053 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3054 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003055 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003056 }
David Chisnall5778fce2009-08-31 16:41:57 +00003057
Chris Lattnere23003d2010-01-09 21:54:33 +00003058 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3059 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003060 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003061 }
3062
Chris Lattnerb35583d2010-04-07 20:49:23 +00003063 CmdArgs.push_back("-ferror-limit");
3064 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003065 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003066 else
3067 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003068
Chandler Carrutha77a7272010-05-06 04:55:18 +00003069 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3070 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003071 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003072 }
3073
3074 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3075 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003076 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003077 }
3078
Richard Smithf6f003a2011-12-16 19:06:07 +00003079 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3080 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003081 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003082 }
3083
Daniel Dunbar2c978472009-11-04 06:24:47 +00003084 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003085 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003086 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003087 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003088 } else {
3089 // If -fmessage-length=N was not specified, determine whether this is a
3090 // terminal and, if so, implicitly define -fmessage-length appropriately.
3091 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003092 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003093 }
3094
John McCallb4a99d32013-02-19 01:57:35 +00003095 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3096 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3097 options::OPT_fvisibility_ms_compat)) {
3098 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3099 CmdArgs.push_back("-fvisibility");
3100 CmdArgs.push_back(A->getValue());
3101 } else {
3102 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3103 CmdArgs.push_back("-fvisibility");
3104 CmdArgs.push_back("hidden");
3105 CmdArgs.push_back("-ftype-visibility");
3106 CmdArgs.push_back("default");
3107 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003108 }
3109
Douglas Gregor08329632010-06-15 17:05:35 +00003110 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003111
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003112 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3113
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003114 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003115 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3116 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003117 CmdArgs.push_back("-ffreestanding");
3118
Daniel Dunbare357d562009-12-03 18:42:11 +00003119 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003120 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003121 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003122 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3123 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003124 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003125 // AltiVec language extensions aren't relevant for assembling.
3126 if (!isa<PreprocessJobAction>(JA) ||
3127 Output.getType() != types::TY_PP_Asm)
3128 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003129 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3130 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003131
Peter Collingbourne32701642013-11-01 18:16:25 +00003132 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3133 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003134
Will Dietz3676d562012-12-30 20:53:28 +00003135 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3136 options::OPT_fno_sanitize_recover,
3137 true))
3138 CmdArgs.push_back("-fno-sanitize-recover");
3139
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003140 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003141 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3142 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3143
Eric Christopher459d2712013-02-19 06:16:53 +00003144 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003145 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003146 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003147 getToolChain().getArch() == llvm::Triple::ppc64 ||
3148 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003149 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003150 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003151
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003152 if (getToolChain().SupportsProfiling())
3153 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003154
3155 // -flax-vector-conversions is default.
3156 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3157 options::OPT_fno_lax_vector_conversions))
3158 CmdArgs.push_back("-fno-lax-vector-conversions");
3159
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003160 if (Args.getLastArg(options::OPT_fapple_kext))
3161 CmdArgs.push_back("-fapple-kext");
3162
David Blaikie690f21e2012-06-14 18:55:27 +00003163 if (Args.hasFlag(options::OPT_frewrite_includes,
3164 options::OPT_fno_rewrite_includes, false))
3165 CmdArgs.push_back("-frewrite-includes");
3166
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003167 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003168 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003169 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003170 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3171 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003172
3173 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3174 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003175 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003176 }
3177
Bob Wilson14adb362012-02-03 06:27:22 +00003178 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003179
Chandler Carruth6e501032011-03-27 00:04:55 +00003180 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3181 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3182 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3183 options::OPT_fno_wrapv)) {
3184 if (A->getOption().matches(options::OPT_fwrapv))
3185 CmdArgs.push_back("-fwrapv");
3186 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3187 options::OPT_fno_strict_overflow)) {
3188 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3189 CmdArgs.push_back("-fwrapv");
3190 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003191
3192 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3193 options::OPT_fno_reroll_loops))
3194 if (A->getOption().matches(options::OPT_freroll_loops))
3195 CmdArgs.push_back("-freroll-loops");
3196
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003197 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003198 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3199 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003200
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003201 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3202
Mahesha S6a682be42012-10-27 07:47:56 +00003203
Daniel Dunbar4930e332009-11-17 08:07:36 +00003204 // -stack-protector=0 is default.
3205 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003206 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3207 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003208 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003209 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003210 if (A->getOption().matches(options::OPT_fstack_protector))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003211 StackProtectorLevel = LangOptions::SSPOn;
3212 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3213 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003214 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003215 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003216 } else {
3217 StackProtectorLevel =
3218 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3219 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003220 if (StackProtectorLevel) {
3221 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003222 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003223 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003224
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003225 // --param ssp-buffer-size=
3226 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3227 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003228 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003229 if (Str.startswith("ssp-buffer-size=")) {
3230 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003231 CmdArgs.push_back("-stack-protector-buffer-size");
3232 // FIXME: Verify the argument is a valid integer.
3233 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003234 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003235 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003236 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003237 }
3238
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003239 // Translate -mstackrealign
3240 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3241 false)) {
3242 CmdArgs.push_back("-backend-option");
3243 CmdArgs.push_back("-force-align-stack");
3244 }
3245 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3246 false)) {
3247 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3248 }
3249
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003250 if (Args.hasArg(options::OPT_mstack_alignment)) {
3251 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3252 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003253 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003254 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003255 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003256 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3257 options::OPT_munaligned_access)) {
3258 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3259 CmdArgs.push_back("-backend-option");
3260 CmdArgs.push_back("-arm-strict-align");
3261 } else {
3262 CmdArgs.push_back("-backend-option");
3263 CmdArgs.push_back("-arm-no-strict-align");
3264 }
Renato Golina146a482013-08-24 14:44:41 +00003265 }
Chad Rosier60027022012-11-09 17:29:19 +00003266 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003267
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003268 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3269 options::OPT_mno_restrict_it)) {
3270 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3271 CmdArgs.push_back("-backend-option");
3272 CmdArgs.push_back("-arm-restrict-it");
3273 } else {
3274 CmdArgs.push_back("-backend-option");
3275 CmdArgs.push_back("-arm-no-restrict-it");
3276 }
3277 }
3278
Daniel Dunbard18049a2009-04-07 21:16:11 +00003279 // Forward -f options with positive and negative forms; we translate
3280 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003281 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3282 StringRef fname = A->getValue();
3283 if (!llvm::sys::fs::exists(fname))
3284 D.Diag(diag::err_drv_no_such_file) << fname;
3285 else
3286 A->render(Args, CmdArgs);
3287 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003288
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003289 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003290 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003291 CmdArgs.push_back("-fapple-kext");
3292 if (!Args.hasArg(options::OPT_fbuiltin))
3293 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003294 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003295 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003296 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003297 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003298 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003299
Nuno Lopes13c88c72009-12-16 16:59:22 +00003300 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3301 options::OPT_fno_assume_sane_operator_new))
3302 CmdArgs.push_back("-fno-assume-sane-operator-new");
3303
Daniel Dunbar4930e332009-11-17 08:07:36 +00003304 // -fblocks=0 is default.
3305 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003306 getToolChain().IsBlocksDefault()) ||
3307 (Args.hasArg(options::OPT_fgnu_runtime) &&
3308 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3309 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003310 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003311
3312 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3313 !getToolChain().hasBlocksRuntime())
3314 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003315 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003316
Douglas Gregor226173a2012-01-18 15:19:58 +00003317 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3318 // users must also pass -fcxx-modules. The latter flag will disappear once the
3319 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003320 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003321 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3322 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3323 options::OPT_fno_cxx_modules,
3324 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003325 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003326 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003327 HaveModules = true;
3328 }
3329 }
3330
Daniel Jasper07e6c402013-08-05 20:26:17 +00003331 // -fmodule-maps enables module map processing (off by default) for header
3332 // checking. It is implied by -fmodules.
3333 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3334 false)) {
3335 CmdArgs.push_back("-fmodule-maps");
3336 }
3337
Daniel Jasperac42b752013-10-21 06:34:34 +00003338 // -fmodules-decluse checks that modules used are declared so (off by
3339 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003340 if (Args.hasFlag(options::OPT_fmodules_decluse,
3341 options::OPT_fno_modules_decluse,
3342 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003343 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003344 }
3345
Daniel Jasperac42b752013-10-21 06:34:34 +00003346 // -fmodule-name specifies the module that is currently being built (or
3347 // used for header checking by -fmodule-maps).
3348 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3349 A->claim();
3350 A->render(Args, CmdArgs);
3351 }
3352
3353 // -fmodule-map-file can be used to specify a file containing module
3354 // definitions.
3355 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3356 A->claim();
3357 A->render(Args, CmdArgs);
3358 }
3359
Douglas Gregor35b04d62013-02-07 19:01:24 +00003360 // If a module path was provided, pass it along. Otherwise, use a temporary
3361 // directory.
3362 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3363 A->claim();
3364 if (HaveModules) {
3365 A->render(Args, CmdArgs);
3366 }
3367 } else if (HaveModules) {
3368 SmallString<128> DefaultModuleCache;
3369 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3370 DefaultModuleCache);
Douglas Gregor23c7d672013-03-21 21:48:48 +00003371 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3372 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00003373 const char Arg[] = "-fmodules-cache-path=";
3374 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3375 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003376 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3377 }
3378
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003379 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path)) {
3380 A->claim();
3381 if (HaveModules) {
3382 A->render(Args, CmdArgs);
3383 }
3384 }
3385
Douglas Gregor35b04d62013-02-07 19:01:24 +00003386 // Pass through all -fmodules-ignore-macro arguments.
3387 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003388 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3389 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003390
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003391 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3392
3393 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3394 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3395 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3396
3397 Args.AddLastArg(CmdArgs,
3398 options::OPT_fmodules_validate_once_per_build_session);
3399 }
3400
Ben Langmuirdcf73862014-03-12 00:06:17 +00003401 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3402
John McCalldfea9982010-04-09 19:12:06 +00003403 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003404 if (Args.hasFlag(options::OPT_fno_access_control,
3405 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003406 false))
John McCall3155f572010-04-09 19:03:51 +00003407 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003408
Anders Carlssond470fef2010-11-21 00:09:52 +00003409 // -felide-constructors is the default.
3410 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3411 options::OPT_felide_constructors,
3412 false))
3413 CmdArgs.push_back("-fno-elide-constructors");
3414
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003415 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003416 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003417 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003418 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003419
Richard Smith52be6192012-11-05 22:04:41 +00003420 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003421 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003422 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003423 Args.getLastArg(options::OPT_mkernel,
3424 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003425 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003426 D.Diag(diag::err_drv_argument_not_allowed_with)
3427 << "-fsanitize=vptr" << NoRttiArg;
3428 }
3429 }
3430
Tony Linthicum76329bf2011-12-12 21:14:55 +00003431 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003432 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003433 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003434 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003435 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003436 CmdArgs.push_back("-fshort-enums");
3437
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003438 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003439 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003440 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003441 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003442
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003443 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003444 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003445 options::OPT_fno_threadsafe_statics))
3446 CmdArgs.push_back("-fno-threadsafe-statics");
3447
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003448 // -fuse-cxa-atexit is default.
Rafael Espindolaa6775b62013-11-04 17:13:51 +00003449 if (!Args.hasFlag(
3450 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3451 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3452 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Robert Lytton6b1deb42013-11-12 10:09:22 +00003453 getToolChain().getArch() != llvm::Triple::hexagon &&
3454 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003455 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003456 CmdArgs.push_back("-fno-use-cxa-atexit");
3457
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003458 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003459 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003460 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3461 CmdArgs.push_back("-fms-extensions");
3462
Francois Pichet1b4f1632011-09-17 04:32:15 +00003463 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003464 if (Args.hasFlag(options::OPT_fms_compatibility,
3465 options::OPT_fno_ms_compatibility,
3466 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3467 Args.hasFlag(options::OPT_fms_extensions,
3468 options::OPT_fno_ms_extensions,
3469 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003470 CmdArgs.push_back("-fms-compatibility");
3471
Reid Klecknerc106fda2013-09-18 00:33:59 +00003472 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003473 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3474 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3475 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003476 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003477 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003478 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003479 else
3480 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3481 }
3482
3483
Eric Christopher5ecce122013-02-18 00:38:31 +00003484 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003485 if (Args.hasFlag(options::OPT_fborland_extensions,
3486 options::OPT_fno_borland_extensions, false))
3487 CmdArgs.push_back("-fborland-extensions");
3488
Francois Pichet02744872011-09-01 16:38:08 +00003489 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3490 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003491 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3492 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00003493 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003494 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003495
Chandler Carruthe03aa552010-04-17 20:17:31 +00003496 // -fgnu-keywords default varies depending on language; only pass if
3497 // specified.
3498 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003499 options::OPT_fno_gnu_keywords))
3500 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003501
Rafael Espindola922a6242011-06-02 17:30:53 +00003502 if (Args.hasFlag(options::OPT_fgnu89_inline,
3503 options::OPT_fno_gnu89_inline,
3504 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003505 CmdArgs.push_back("-fgnu89-inline");
3506
Chad Rosier9c76d242012-03-15 22:31:42 +00003507 if (Args.hasArg(options::OPT_fno_inline))
3508 CmdArgs.push_back("-fno-inline");
3509
Chad Rosier64d6be92012-03-06 21:17:19 +00003510 if (Args.hasArg(options::OPT_fno_inline_functions))
3511 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003512
John McCall5fb5df92012-06-20 06:18:46 +00003513 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003514
John McCall5fb5df92012-06-20 06:18:46 +00003515 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003516 // legacy is the default. Except for deployment taget of 10.5,
3517 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3518 // gets ignored silently.
3519 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003520 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3521 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003522 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003523 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003524 if (getToolChain().UseObjCMixedDispatch())
3525 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3526 else
3527 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3528 }
3529 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003530
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003531 // When ObjectiveC legacy runtime is in effect on MacOSX,
3532 // turn on the option to do Array/Dictionary subscripting
3533 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003534 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3535 getToolChain().getTriple().isMacOSX() &&
3536 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3537 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003538 objcRuntime.isNeXTFamily())
3539 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3540
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003541 // -fencode-extended-block-signature=1 is default.
3542 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3543 CmdArgs.push_back("-fencode-extended-block-signature");
3544 }
3545
John McCall24fc0de2011-07-06 00:26:06 +00003546 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3547 // NOTE: This logic is duplicated in ToolChains.cpp.
3548 bool ARC = isObjCAutoRefCount(Args);
3549 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003550 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003551
John McCall24fc0de2011-07-06 00:26:06 +00003552 CmdArgs.push_back("-fobjc-arc");
3553
Chandler Carruth491db322011-11-04 07:34:47 +00003554 // FIXME: It seems like this entire block, and several around it should be
3555 // wrapped in isObjC, but for now we just use it here as this is where it
3556 // was being used previously.
3557 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3558 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3559 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3560 else
3561 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3562 }
3563
John McCall24fc0de2011-07-06 00:26:06 +00003564 // Allow the user to enable full exceptions code emission.
3565 // We define off for Objective-CC, on for Objective-C++.
3566 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3567 options::OPT_fno_objc_arc_exceptions,
3568 /*default*/ types::isCXX(InputType)))
3569 CmdArgs.push_back("-fobjc-arc-exceptions");
3570 }
3571
3572 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3573 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003574 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003575 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003576
John McCall24fc0de2011-07-06 00:26:06 +00003577 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3578 // takes precedence.
3579 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3580 if (!GCArg)
3581 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3582 if (GCArg) {
3583 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003584 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003585 << GCArg->getAsString(Args);
3586 } else if (getToolChain().SupportsObjCGC()) {
3587 GCArg->render(Args, CmdArgs);
3588 } else {
3589 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003590 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003591 << GCArg->getAsString(Args);
3592 }
3593 }
3594
John McCallb5f652e2011-06-22 00:53:57 +00003595 // Add exception args.
3596 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003597 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003598
3599 if (getToolChain().UseSjLjExceptions())
3600 CmdArgs.push_back("-fsjlj-exceptions");
3601
3602 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003603 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3604 options::OPT_fno_assume_sane_operator_new))
3605 CmdArgs.push_back("-fno-assume-sane-operator-new");
3606
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003607 // -fconstant-cfstrings is default, and may be subject to argument translation
3608 // on Darwin.
3609 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3610 options::OPT_fno_constant_cfstrings) ||
3611 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3612 options::OPT_mno_constant_cfstrings))
3613 CmdArgs.push_back("-fno-constant-cfstrings");
3614
John Thompsoned4e2952009-11-05 20:14:16 +00003615 // -fshort-wchar default varies depending on platform; only
3616 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003617 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3618 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003619 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003620
Hans Wennborg28c96312013-07-31 23:39:13 +00003621 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003622 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003623 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003624 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003625 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003626
Daniel Dunbar096ed292011-10-05 21:04:55 +00003627 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3628 // -fno-pack-struct doesn't apply to -fpack-struct=.
3629 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003630 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003631 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003632 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003633 } else if (Args.hasFlag(options::OPT_fpack_struct,
3634 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003635 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003636 }
3637
Robert Lytton0e076492013-08-13 09:43:10 +00003638 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003639 if (!Args.hasArg(options::OPT_fcommon))
3640 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003641 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003642 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003643
Daniel Dunbard18049a2009-04-07 21:16:11 +00003644 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003645 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003646 CmdArgs.push_back("-fno-common");
3647
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003648 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003649 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003650 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003651 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003652 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003653 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3654
Daniel Dunbar6358d682010-10-15 22:30:42 +00003655 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3656 if (!Args.hasFlag(options::OPT_ffor_scope,
3657 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003658 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003659 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3660
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003661 // -fcaret-diagnostics is default.
3662 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3663 options::OPT_fno_caret_diagnostics, true))
3664 CmdArgs.push_back("-fno-caret-diagnostics");
3665
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003666 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003667 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003668 options::OPT_fno_diagnostics_fixit_info))
3669 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003670
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003671 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003672 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003673 options::OPT_fno_diagnostics_show_option))
3674 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003675
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003676 if (const Arg *A =
3677 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3678 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003679 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003680 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003681
Douglas Gregor643c9222011-05-21 17:07:29 +00003682 if (const Arg *A =
3683 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3684 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003685 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003686 }
3687
Chandler Carruthb6766f02011-03-27 01:50:55 +00003688 if (Arg *A = Args.getLastArg(
3689 options::OPT_fdiagnostics_show_note_include_stack,
3690 options::OPT_fno_diagnostics_show_note_include_stack)) {
3691 if (A->getOption().matches(
3692 options::OPT_fdiagnostics_show_note_include_stack))
3693 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3694 else
3695 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3696 }
3697
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003698 // Color diagnostics are the default, unless the terminal doesn't support
3699 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003700 // Support both clang's -f[no-]color-diagnostics and gcc's
3701 // -f[no-]diagnostics-colors[=never|always|auto].
3702 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3703 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3704 it != ie; ++it) {
3705 const Option &O = (*it)->getOption();
3706 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3707 !O.matches(options::OPT_fdiagnostics_color) &&
3708 !O.matches(options::OPT_fno_color_diagnostics) &&
3709 !O.matches(options::OPT_fno_diagnostics_color) &&
3710 !O.matches(options::OPT_fdiagnostics_color_EQ))
3711 continue;
3712
3713 (*it)->claim();
3714 if (O.matches(options::OPT_fcolor_diagnostics) ||
3715 O.matches(options::OPT_fdiagnostics_color)) {
3716 ShowColors = Colors_On;
3717 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3718 O.matches(options::OPT_fno_diagnostics_color)) {
3719 ShowColors = Colors_Off;
3720 } else {
3721 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3722 StringRef value((*it)->getValue());
3723 if (value == "always")
3724 ShowColors = Colors_On;
3725 else if (value == "never")
3726 ShowColors = Colors_Off;
3727 else if (value == "auto")
3728 ShowColors = Colors_Auto;
3729 else
3730 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3731 << ("-fdiagnostics-color=" + value).str();
3732 }
3733 }
3734 if (ShowColors == Colors_On ||
3735 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003736 CmdArgs.push_back("-fcolor-diagnostics");
3737
Nico Rieck7857d462013-09-11 00:38:02 +00003738 if (Args.hasArg(options::OPT_fansi_escape_codes))
3739 CmdArgs.push_back("-fansi-escape-codes");
3740
Daniel Dunbardb097022009-06-08 21:13:54 +00003741 if (!Args.hasFlag(options::OPT_fshow_source_location,
3742 options::OPT_fno_show_source_location))
3743 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003744
Douglas Gregor643c9222011-05-21 17:07:29 +00003745 if (!Args.hasFlag(options::OPT_fshow_column,
3746 options::OPT_fno_show_column,
3747 true))
3748 CmdArgs.push_back("-fno-show-column");
3749
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003750 if (!Args.hasFlag(options::OPT_fspell_checking,
3751 options::OPT_fno_spell_checking))
3752 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003753
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003754
Chad Rosierc8e56e82012-12-05 21:08:21 +00003755 // -fno-asm-blocks is default.
3756 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3757 false))
3758 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003759
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003760 // Enable vectorization per default according to the optimization level
3761 // selected. For optimization levels that want vectorization we use the alias
3762 // option to simplify the hasFlag logic.
3763 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3764 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003765 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003766 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003767 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003768 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003769
Rafael Espindolaf818ef42013-08-01 23:56:42 +00003770 // -fslp-vectorize is default.
3771 if (Args.hasFlag(options::OPT_fslp_vectorize,
3772 options::OPT_fno_slp_vectorize, true))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00003773 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00003774
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003775 // -fno-slp-vectorize-aggressive is default.
3776 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003777 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003778 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003779
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00003780 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3781 A->render(Args, CmdArgs);
3782
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003783 // -fdollars-in-identifiers default varies depending on platform and
3784 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003785 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003786 options::OPT_fno_dollars_in_identifiers)) {
3787 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003788 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003789 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003790 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003791 }
3792
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003793 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3794 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003795 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003796 options::OPT_fno_unit_at_a_time)) {
3797 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003798 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003799 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003800
Eli Friedman055c9702011-11-02 01:53:16 +00003801 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3802 options::OPT_fno_apple_pragma_pack, false))
3803 CmdArgs.push_back("-fapple-pragma-pack");
3804
Eli Benderskyc95cfe82013-07-24 18:20:14 +00003805 // le32-specific flags:
3806 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3807 // by default.
3808 if (getToolChain().getArch() == llvm::Triple::le32) {
3809 CmdArgs.push_back("-fno-math-builtin");
3810 }
3811
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003812 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003813 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003814 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003815#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00003816 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003817 (getToolChain().getArch() == llvm::Triple::arm ||
3818 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003819 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3820 CmdArgs.push_back("-fno-builtin-strcat");
3821 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3822 CmdArgs.push_back("-fno-builtin-strcpy");
3823 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003824#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003825
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003826 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00003827 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003828 options::OPT_traditional_cpp)) {
3829 if (isa<PreprocessJobAction>(JA))
3830 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003831 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003832 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003833 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003834
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003835 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00003836 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003837
3838 // Handle serialized diagnostics.
3839 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3840 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003841 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003842 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003843
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003844 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3845 CmdArgs.push_back("-fretain-comments-from-system-headers");
3846
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003847 // Forward -fcomment-block-commands to -cc1.
3848 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00003849 // Forward -fparse-all-comments to -cc1.
3850 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003851
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003852 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3853 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003854 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003855 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3856 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003857 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003858
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003859 // We translate this by hand to the -cc1 argument, since nightly test uses
3860 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003861 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003862 CmdArgs.push_back("-disable-llvm-optzns");
3863 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003864 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003865 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003866
Daniel Dunbard67a3222009-03-30 06:36:42 +00003867 if (Output.getType() == types::TY_Dependencies) {
3868 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003869 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003870 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003871 CmdArgs.push_back(Output.getFilename());
3872 } else {
3873 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003874 }
3875
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003876 for (InputInfoList::const_iterator
3877 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3878 const InputInfo &II = *it;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00003879
3880 addDashXForInput(Args, II, CmdArgs);
3881
Daniel Dunbarb440f562010-08-02 02:38:21 +00003882 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003883 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003884 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003885 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003886 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003887
Chris Lattnere9d7d782009-11-03 19:50:27 +00003888 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3889
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003890 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003891
3892 // Optionally embed the -cc1 level arguments into the debug info, for build
3893 // analysis.
3894 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003895 ArgStringList OriginalArgs;
3896 for (ArgList::const_iterator it = Args.begin(),
3897 ie = Args.end(); it != ie; ++it)
3898 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003899
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003900 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003901 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003902 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003903 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003904 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003905 }
3906 CmdArgs.push_back("-dwarf-debug-flags");
3907 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3908 }
3909
Eric Christopherd3804002013-02-22 20:12:52 +00003910 // Add the split debug info name to the command lines here so we
3911 // can propagate it to the backend.
3912 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003913 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00003914 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00003915 const char *SplitDwarfOut;
3916 if (SplitDwarf) {
3917 CmdArgs.push_back("-split-dwarf-file");
3918 SplitDwarfOut = SplitDebugName(Args, Inputs);
3919 CmdArgs.push_back(SplitDwarfOut);
3920 }
3921
3922 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00003923 if (Args.hasArg(options::OPT__SLASH_fallback) &&
3924 Output.getType() == types::TY_Object) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00003925 tools::visualstudio::Compile CL(getToolChain());
3926 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3927 LinkingOutput);
3928 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3929 } else {
3930 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3931 }
3932
Daniel Dunbar17731772009-03-23 19:03:36 +00003933
Eric Christopherf1545832013-02-22 23:50:16 +00003934 // Handle the debug info splitting at object creation time if we're
3935 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00003936 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00003937 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00003938 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00003939
Roman Divacky178e01602011-02-10 16:52:03 +00003940 if (Arg *A = Args.getLastArg(options::OPT_pg))
3941 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003942 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003943 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003944
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003945 // Claim some arguments which clang supports automatically.
3946
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003947 // -fpch-preprocess is used with gcc to add a special marker in the output to
3948 // include the PCH file. Clang's PTH solution is completely transparent, so we
3949 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003950 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003951
Daniel Dunbar17731772009-03-23 19:03:36 +00003952 // Claim some arguments which clang doesn't support, but we don't
3953 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003954 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3955 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003956
Rafael Espindolab0092d72013-09-04 19:37:35 +00003957 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00003958 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003959}
3960
John McCall5fb5df92012-06-20 06:18:46 +00003961/// Add options related to the Objective-C runtime/ABI.
3962///
3963/// Returns true if the runtime is non-fragile.
3964ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3965 ArgStringList &cmdArgs,
3966 RewriteKind rewriteKind) const {
3967 // Look for the controlling runtime option.
3968 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3969 options::OPT_fgnu_runtime,
3970 options::OPT_fobjc_runtime_EQ);
3971
3972 // Just forward -fobjc-runtime= to the frontend. This supercedes
3973 // options about fragility.
3974 if (runtimeArg &&
3975 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3976 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003977 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003978 if (runtime.tryParse(value)) {
3979 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3980 << value;
3981 }
3982
3983 runtimeArg->render(args, cmdArgs);
3984 return runtime;
3985 }
3986
3987 // Otherwise, we'll need the ABI "version". Version numbers are
3988 // slightly confusing for historical reasons:
3989 // 1 - Traditional "fragile" ABI
3990 // 2 - Non-fragile ABI, version 1
3991 // 3 - Non-fragile ABI, version 2
3992 unsigned objcABIVersion = 1;
3993 // If -fobjc-abi-version= is present, use that to set the version.
3994 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003995 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003996 if (value == "1")
3997 objcABIVersion = 1;
3998 else if (value == "2")
3999 objcABIVersion = 2;
4000 else if (value == "3")
4001 objcABIVersion = 3;
4002 else
4003 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4004 << value;
4005 } else {
4006 // Otherwise, determine if we are using the non-fragile ABI.
4007 bool nonFragileABIIsDefault =
4008 (rewriteKind == RK_NonFragile ||
4009 (rewriteKind == RK_None &&
4010 getToolChain().IsObjCNonFragileABIDefault()));
4011 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4012 options::OPT_fno_objc_nonfragile_abi,
4013 nonFragileABIIsDefault)) {
4014 // Determine the non-fragile ABI version to use.
4015#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4016 unsigned nonFragileABIVersion = 1;
4017#else
4018 unsigned nonFragileABIVersion = 2;
4019#endif
4020
4021 if (Arg *abiArg = args.getLastArg(
4022 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004023 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004024 if (value == "1")
4025 nonFragileABIVersion = 1;
4026 else if (value == "2")
4027 nonFragileABIVersion = 2;
4028 else
4029 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4030 << value;
4031 }
4032
4033 objcABIVersion = 1 + nonFragileABIVersion;
4034 } else {
4035 objcABIVersion = 1;
4036 }
4037 }
4038
4039 // We don't actually care about the ABI version other than whether
4040 // it's non-fragile.
4041 bool isNonFragile = objcABIVersion != 1;
4042
4043 // If we have no runtime argument, ask the toolchain for its default runtime.
4044 // However, the rewriter only really supports the Mac runtime, so assume that.
4045 ObjCRuntime runtime;
4046 if (!runtimeArg) {
4047 switch (rewriteKind) {
4048 case RK_None:
4049 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4050 break;
4051 case RK_Fragile:
4052 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4053 break;
4054 case RK_NonFragile:
4055 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4056 break;
4057 }
4058
4059 // -fnext-runtime
4060 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4061 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004062 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004063 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4064
4065 // Otherwise, build for a generic macosx port.
4066 } else {
4067 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4068 }
4069
4070 // -fgnu-runtime
4071 } else {
4072 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004073 // Legacy behaviour is to target the gnustep runtime if we are i
4074 // non-fragile mode or the GCC runtime in fragile mode.
4075 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004076 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004077 else
4078 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004079 }
4080
4081 cmdArgs.push_back(args.MakeArgString(
4082 "-fobjc-runtime=" + runtime.getAsString()));
4083 return runtime;
4084}
4085
Hans Wennborg75958c42013-08-08 00:17:41 +00004086void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4087 unsigned RTOptionID = options::OPT__SLASH_MT;
4088
Hans Wennborgf1a74252013-09-10 20:18:04 +00004089 if (Args.hasArg(options::OPT__SLASH_LDd))
4090 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4091 // but defining _DEBUG is sticky.
4092 RTOptionID = options::OPT__SLASH_MTd;
4093
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004094 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004095 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004096
Hans Wennborg75958c42013-08-08 00:17:41 +00004097 switch(RTOptionID) {
4098 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004099 if (Args.hasArg(options::OPT__SLASH_LDd))
4100 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004101 CmdArgs.push_back("-D_MT");
4102 CmdArgs.push_back("-D_DLL");
4103 CmdArgs.push_back("--dependent-lib=msvcrt");
4104 break;
4105 case options::OPT__SLASH_MDd:
4106 CmdArgs.push_back("-D_DEBUG");
4107 CmdArgs.push_back("-D_MT");
4108 CmdArgs.push_back("-D_DLL");
4109 CmdArgs.push_back("--dependent-lib=msvcrtd");
4110 break;
4111 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004112 if (Args.hasArg(options::OPT__SLASH_LDd))
4113 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004114 CmdArgs.push_back("-D_MT");
4115 CmdArgs.push_back("--dependent-lib=libcmt");
4116 break;
4117 case options::OPT__SLASH_MTd:
4118 CmdArgs.push_back("-D_DEBUG");
4119 CmdArgs.push_back("-D_MT");
4120 CmdArgs.push_back("--dependent-lib=libcmtd");
4121 break;
4122 default:
4123 llvm_unreachable("Unexpected option ID.");
4124 }
4125
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004126 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4127 // users want. The /Za flag to cl.exe turns this off, but it's not
4128 // implemented in clang.
4129 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004130
Hans Wennborg0fd62072013-08-09 00:32:23 +00004131 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4132 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004133
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004134 // RTTI is currently not supported, so disable it by default.
4135 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4136 CmdArgs.push_back("-fno-rtti");
4137
David Majnemer86c318f2014-02-11 21:05:00 +00004138 const Driver &D = getToolChain().getDriver();
4139 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4140 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4141 if (MostGeneralArg && BestCaseArg)
4142 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4143 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4144
4145 if (MostGeneralArg) {
4146 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4147 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4148 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4149
4150 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4151 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4152 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4153 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4154 << FirstConflict->getAsString(Args)
4155 << SecondConflict->getAsString(Args);
4156
4157 if (SingleArg)
4158 CmdArgs.push_back("-fms-memptr-rep=single");
4159 else if (MultipleArg)
4160 CmdArgs.push_back("-fms-memptr-rep=multiple");
4161 else
4162 CmdArgs.push_back("-fms-memptr-rep=virtual");
4163 }
4164
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004165 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4166 A->render(Args, CmdArgs);
4167
Hans Wennborg81f74482013-09-10 01:07:07 +00004168 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4169 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004170 if (Args.hasArg(options::OPT__SLASH_fallback))
4171 CmdArgs.push_back("msvc-fallback");
4172 else
4173 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004174 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004175}
4176
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004177void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004178 const InputInfo &Output,
4179 const InputInfoList &Inputs,
4180 const ArgList &Args,
4181 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004182 ArgStringList CmdArgs;
4183
4184 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4185 const InputInfo &Input = Inputs[0];
4186
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004187 // Don't warn about "clang -w -c foo.s"
4188 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004189 // and "clang -emit-llvm -c foo.s"
4190 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004191
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004192 // Invoke ourselves in -cc1as mode.
4193 //
4194 // FIXME: Implement custom jobs for internal actions.
4195 CmdArgs.push_back("-cc1as");
4196
4197 // Add the "effective" target triple.
4198 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004199 std::string TripleStr =
4200 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004201 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4202
4203 // Set the output mode, we currently only expect to be used as a real
4204 // assembler.
4205 CmdArgs.push_back("-filetype");
4206 CmdArgs.push_back("obj");
4207
Eric Christopher45f2e712012-12-18 00:31:10 +00004208 // Set the main file name, so that debug info works even with
4209 // -save-temps or preprocessed assembly.
4210 CmdArgs.push_back("-main-file-name");
4211 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4212
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004213 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004214 const llvm::Triple &Triple = getToolChain().getTriple();
4215 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004216 if (!CPU.empty()) {
4217 CmdArgs.push_back("-target-cpu");
4218 CmdArgs.push_back(Args.MakeArgString(CPU));
4219 }
4220
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004221 // Add the target features
4222 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004223 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004224
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004225 // Ignore explicit -force_cpusubtype_ALL option.
4226 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004227
Eric Christopherfc3ee562012-01-10 00:38:01 +00004228 // Determine the original source input.
4229 const Action *SourceAction = &JA;
4230 while (SourceAction->getKind() != Action::InputClass) {
4231 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4232 SourceAction = SourceAction->getInputs()[0];
4233 }
4234
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004235 // Forward -g and handle debug info related flags, assuming we are dealing
4236 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004237 if (SourceAction->getType() == types::TY_Asm ||
4238 SourceAction->getType() == types::TY_PP_Asm) {
4239 Args.ClaimAllArgs(options::OPT_g_Group);
4240 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4241 if (!A->getOption().matches(options::OPT_g0))
4242 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004243
4244 // Add the -fdebug-compilation-dir flag if needed.
4245 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004246
4247 // Set the AT_producer to the clang version when using the integrated
4248 // assembler on assembly source files.
4249 CmdArgs.push_back("-dwarf-debug-producer");
4250 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004251 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004252
4253 // Optionally embed the -cc1as level arguments into the debug info, for build
4254 // analysis.
4255 if (getToolChain().UseDwarfDebugFlags()) {
4256 ArgStringList OriginalArgs;
4257 for (ArgList::const_iterator it = Args.begin(),
4258 ie = Args.end(); it != ie; ++it)
4259 (*it)->render(Args, OriginalArgs);
4260
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004261 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004262 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4263 Flags += Exec;
4264 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4265 Flags += " ";
4266 Flags += OriginalArgs[i];
4267 }
4268 CmdArgs.push_back("-dwarf-debug-flags");
4269 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4270 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004271
4272 // FIXME: Add -static support, once we have it.
4273
David Blaikie372d9502014-01-17 03:17:40 +00004274 // Consume all the warning flags. Usually this would be handled more
4275 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4276 // doesn't handle that so rather than warning about unused flags that are
4277 // actually used, we'll lie by omission instead.
4278 // FIXME: Stop lying and consume only the appropriate driver flags
4279 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4280 ie = Args.filtered_end();
4281 it != ie; ++it)
4282 (*it)->claim();
4283
David Blaikie9260ed62013-07-25 21:19:01 +00004284 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4285 getToolChain().getDriver());
4286
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004287 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004288
4289 assert(Output.isFilename() && "Unexpected lipo output.");
4290 CmdArgs.push_back("-o");
4291 CmdArgs.push_back(Output.getFilename());
4292
Daniel Dunbarb440f562010-08-02 02:38:21 +00004293 assert(Input.isFilename() && "Invalid input.");
4294 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004295
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004296 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004297 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004298
4299 // Handle the debug info splitting at object creation time if we're
4300 // creating an object.
4301 // TODO: Currently only works on linux with newer objcopy.
4302 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004303 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004304 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4305 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004306}
4307
Daniel Dunbara3246a02009-03-18 08:07:30 +00004308void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004309 const InputInfo &Output,
4310 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004311 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004312 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004313 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004314 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004315
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004316 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004317 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004318 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004319 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004320 // Don't forward any -g arguments to assembly steps.
4321 if (isa<AssembleJobAction>(JA) &&
4322 A->getOption().matches(options::OPT_g_Group))
4323 continue;
4324
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004325 // Don't forward any -W arguments to assembly and link steps.
4326 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4327 A->getOption().matches(options::OPT_W_Group))
4328 continue;
4329
Daniel Dunbar2da02722009-03-19 07:55:12 +00004330 // It is unfortunate that we have to claim here, as this means
4331 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004332 // platforms using a generic gcc, even if we are just using gcc
4333 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004334 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004335 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004336 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004337 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004338
Daniel Dunbar4e295052010-01-25 22:35:08 +00004339 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004340
4341 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004342 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004343 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004344 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004345
4346 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004347 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004348 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004349 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004350 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004351 else if (Arch == llvm::Triple::ppc64le)
4352 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004353 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004354 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004355 }
4356
Daniel Dunbar5716d872009-05-02 21:41:52 +00004357 // Try to force gcc to match the tool chain we want, if we recognize
4358 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004359 //
4360 // FIXME: The triple class should directly provide the information we want
4361 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004362 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004363 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004364 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4365 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004366 CmdArgs.push_back("-m64");
4367
Daniel Dunbarb440f562010-08-02 02:38:21 +00004368 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004369 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004370 CmdArgs.push_back(Output.getFilename());
4371 } else {
4372 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004373 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004374 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004375
Tony Linthicum76329bf2011-12-12 21:14:55 +00004376 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4377 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004378
4379 // Only pass -x if gcc will understand it; otherwise hope gcc
4380 // understands the suffix correctly. The main use case this would go
4381 // wrong in is for linker inputs if they happened to have an odd
4382 // suffix; really the only way to get this to happen is a command
4383 // like '-x foobar a.c' which will treat a.c like a linker input.
4384 //
4385 // FIXME: For the linker case specifically, can we safely convert
4386 // inputs into '-Wl,' options?
4387 for (InputInfoList::const_iterator
4388 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4389 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004390
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004391 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004392 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4393 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004394 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004395 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004396 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004397 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004398 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004399 else if (II.getType() == types::TY_ModuleFile)
4400 D.Diag(diag::err_drv_no_module_support)
4401 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004402
Daniel Dunbara3246a02009-03-18 08:07:30 +00004403 if (types::canTypeBeUserSpecified(II.getType())) {
4404 CmdArgs.push_back("-x");
4405 CmdArgs.push_back(types::getTypeName(II.getType()));
4406 }
4407
Daniel Dunbarb440f562010-08-02 02:38:21 +00004408 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004409 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004410 else {
4411 const Arg &A = II.getInputArg();
4412
4413 // Reverse translate some rewritten options.
4414 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4415 CmdArgs.push_back("-lstdc++");
4416 continue;
4417 }
4418
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004419 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004420 A.render(Args, CmdArgs);
4421 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004422 }
4423
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004424 const std::string customGCCName = D.getCCCGenericGCCName();
4425 const char *GCCName;
4426 if (!customGCCName.empty())
4427 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004428 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004429 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004430 } else
4431 GCCName = "gcc";
4432
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004433 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004434 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004435 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004436}
4437
Daniel Dunbar4e295052010-01-25 22:35:08 +00004438void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4439 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004440 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004441}
4442
Daniel Dunbar4e295052010-01-25 22:35:08 +00004443void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4444 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004445 const Driver &D = getToolChain().getDriver();
4446
Daniel Dunbar4e295052010-01-25 22:35:08 +00004447 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004448 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4449 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004450 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004451 else {
4452 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004453 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004454 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004455
Daniel Dunbar4e295052010-01-25 22:35:08 +00004456 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004457 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004458}
4459
Daniel Dunbar4e295052010-01-25 22:35:08 +00004460void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4461 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004462 // The types are (hopefully) good enough.
4463}
4464
Tony Linthicum76329bf2011-12-12 21:14:55 +00004465// Hexagon tools start.
4466void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4467 ArgStringList &CmdArgs) const {
4468
4469}
4470void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4471 const InputInfo &Output,
4472 const InputInfoList &Inputs,
4473 const ArgList &Args,
4474 const char *LinkingOutput) const {
4475
4476 const Driver &D = getToolChain().getDriver();
4477 ArgStringList CmdArgs;
4478
4479 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004480 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004481 CmdArgs.push_back(Args.MakeArgString(MarchString));
4482
4483 RenderExtraToolArgs(JA, CmdArgs);
4484
4485 if (Output.isFilename()) {
4486 CmdArgs.push_back("-o");
4487 CmdArgs.push_back(Output.getFilename());
4488 } else {
4489 assert(Output.isNothing() && "Unexpected output");
4490 CmdArgs.push_back("-fsyntax-only");
4491 }
4492
Matthew Curtise8f80a12012-12-06 17:49:03 +00004493 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4494 if (!SmallDataThreshold.empty())
4495 CmdArgs.push_back(
4496 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004497
Matthew Curtise5df3812012-12-07 17:23:04 +00004498 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4499 options::OPT_Xassembler);
4500
Tony Linthicum76329bf2011-12-12 21:14:55 +00004501 // Only pass -x if gcc will understand it; otherwise hope gcc
4502 // understands the suffix correctly. The main use case this would go
4503 // wrong in is for linker inputs if they happened to have an odd
4504 // suffix; really the only way to get this to happen is a command
4505 // like '-x foobar a.c' which will treat a.c like a linker input.
4506 //
4507 // FIXME: For the linker case specifically, can we safely convert
4508 // inputs into '-Wl,' options?
4509 for (InputInfoList::const_iterator
4510 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4511 const InputInfo &II = *it;
4512
4513 // Don't try to pass LLVM or AST inputs to a generic gcc.
4514 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4515 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4516 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4517 << getToolChain().getTripleString();
4518 else if (II.getType() == types::TY_AST)
4519 D.Diag(clang::diag::err_drv_no_ast_support)
4520 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004521 else if (II.getType() == types::TY_ModuleFile)
4522 D.Diag(diag::err_drv_no_module_support)
4523 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004524
4525 if (II.isFilename())
4526 CmdArgs.push_back(II.getFilename());
4527 else
4528 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4529 II.getInputArg().render(Args, CmdArgs);
4530 }
4531
4532 const char *GCCName = "hexagon-as";
4533 const char *Exec =
4534 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4535 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4536
4537}
4538void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4539 ArgStringList &CmdArgs) const {
4540 // The types are (hopefully) good enough.
4541}
4542
4543void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4544 const InputInfo &Output,
4545 const InputInfoList &Inputs,
4546 const ArgList &Args,
4547 const char *LinkingOutput) const {
4548
Matthew Curtise689b052012-12-06 15:46:07 +00004549 const toolchains::Hexagon_TC& ToolChain =
4550 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4551 const Driver &D = ToolChain.getDriver();
4552
Tony Linthicum76329bf2011-12-12 21:14:55 +00004553 ArgStringList CmdArgs;
4554
Matthew Curtise689b052012-12-06 15:46:07 +00004555 //----------------------------------------------------------------------------
4556 //
4557 //----------------------------------------------------------------------------
4558 bool hasStaticArg = Args.hasArg(options::OPT_static);
4559 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004560 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004561 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4562 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4563 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4564 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004565
Matthew Curtise689b052012-12-06 15:46:07 +00004566 //----------------------------------------------------------------------------
4567 // Silence warnings for various options
4568 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004569
Matthew Curtise689b052012-12-06 15:46:07 +00004570 Args.ClaimAllArgs(options::OPT_g_Group);
4571 Args.ClaimAllArgs(options::OPT_emit_llvm);
4572 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4573 // handled somewhere else.
4574 Args.ClaimAllArgs(options::OPT_static_libgcc);
4575
4576 //----------------------------------------------------------------------------
4577 //
4578 //----------------------------------------------------------------------------
4579 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4580 e = ToolChain.ExtraOpts.end();
4581 i != e; ++i)
4582 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004583
Matthew Curtisf10a5952012-12-06 14:16:43 +00004584 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4585 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004586
Matthew Curtise689b052012-12-06 15:46:07 +00004587 if (buildingLib) {
4588 CmdArgs.push_back("-shared");
4589 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4590 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004591 }
4592
Matthew Curtise689b052012-12-06 15:46:07 +00004593 if (hasStaticArg)
4594 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004595
Matthew Curtise8f80a12012-12-06 17:49:03 +00004596 if (buildPIE && !buildingLib)
4597 CmdArgs.push_back("-pie");
4598
4599 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4600 if (!SmallDataThreshold.empty()) {
4601 CmdArgs.push_back(
4602 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4603 }
4604
Matthew Curtise689b052012-12-06 15:46:07 +00004605 //----------------------------------------------------------------------------
4606 //
4607 //----------------------------------------------------------------------------
4608 CmdArgs.push_back("-o");
4609 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004610
Matthew Curtise689b052012-12-06 15:46:07 +00004611 const std::string MarchSuffix = "/" + MarchString;
4612 const std::string G0Suffix = "/G0";
4613 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4614 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4615 + "/";
4616 const std::string StartFilesDir = RootDir
4617 + "hexagon/lib"
4618 + (buildingLib
4619 ? MarchG0Suffix : MarchSuffix);
4620
4621 //----------------------------------------------------------------------------
4622 // moslib
4623 //----------------------------------------------------------------------------
4624 std::vector<std::string> oslibs;
4625 bool hasStandalone= false;
4626
4627 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4628 ie = Args.filtered_end(); it != ie; ++it) {
4629 (*it)->claim();
4630 oslibs.push_back((*it)->getValue());
4631 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004632 }
Matthew Curtise689b052012-12-06 15:46:07 +00004633 if (oslibs.empty()) {
4634 oslibs.push_back("standalone");
4635 hasStandalone = true;
4636 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004637
Matthew Curtise689b052012-12-06 15:46:07 +00004638 //----------------------------------------------------------------------------
4639 // Start Files
4640 //----------------------------------------------------------------------------
4641 if (incStdLib && incStartFiles) {
4642
4643 if (!buildingLib) {
4644 if (hasStandalone) {
4645 CmdArgs.push_back(
4646 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4647 }
4648 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4649 }
4650 std::string initObj = useShared ? "/initS.o" : "/init.o";
4651 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4652 }
4653
4654 //----------------------------------------------------------------------------
4655 // Library Search Paths
4656 //----------------------------------------------------------------------------
4657 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4658 for (ToolChain::path_list::const_iterator
4659 i = LibPaths.begin(),
4660 e = LibPaths.end();
4661 i != e;
4662 ++i)
4663 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4664
4665 //----------------------------------------------------------------------------
4666 //
4667 //----------------------------------------------------------------------------
4668 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4669 Args.AddAllArgs(CmdArgs, options::OPT_e);
4670 Args.AddAllArgs(CmdArgs, options::OPT_s);
4671 Args.AddAllArgs(CmdArgs, options::OPT_t);
4672 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4673
4674 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4675
4676 //----------------------------------------------------------------------------
4677 // Libraries
4678 //----------------------------------------------------------------------------
4679 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004680 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004681 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4682 CmdArgs.push_back("-lm");
4683 }
4684
4685 CmdArgs.push_back("--start-group");
4686
4687 if (!buildingLib) {
4688 for(std::vector<std::string>::iterator i = oslibs.begin(),
4689 e = oslibs.end(); i != e; ++i)
4690 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4691 CmdArgs.push_back("-lc");
4692 }
4693 CmdArgs.push_back("-lgcc");
4694
4695 CmdArgs.push_back("--end-group");
4696 }
4697
4698 //----------------------------------------------------------------------------
4699 // End files
4700 //----------------------------------------------------------------------------
4701 if (incStdLib && incStartFiles) {
4702 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4703 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4704 }
4705
4706 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004707 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004708}
4709// Hexagon tools end.
4710
Bernard Ogden31561762013-12-12 13:27:11 +00004711/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4712//
4713// FIXME: tblgen this.
4714const char *arm::getARMCPUForMArch(const ArgList &Args,
4715 const llvm::Triple &Triple) {
4716 StringRef MArch;
4717 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4718 // Otherwise, if we have -march= choose the base CPU for that arch.
4719 MArch = A->getValue();
4720 } else {
4721 // Otherwise, use the Arch from the triple.
4722 MArch = Triple.getArchName();
4723 }
4724
4725 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004726 if (MArch == "native") {
4727 std::string CPU = llvm::sys::getHostCPUName();
4728 if (CPU != "generic") {
4729 // Translate the native cpu into the architecture. The switch below will
4730 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004731 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004732 }
4733 }
4734
4735 if (Triple.getOS() == llvm::Triple::NetBSD) {
4736 if (MArch == "armv6")
4737 return "arm1176jzf-s";
4738 }
4739
4740 const char *result = llvm::StringSwitch<const char *>(MArch)
4741 .Cases("armv2", "armv2a","arm2")
4742 .Case("armv3", "arm6")
4743 .Case("armv3m", "arm7m")
4744 .Case("armv4", "strongarm")
4745 .Case("armv4t", "arm7tdmi")
4746 .Case("thumbv4t", "arm7tdmi")
4747 .Cases("armv5", "armv5t", "arm10tdmi")
4748 .Cases("thumbv5", "thumbv5t", "arm10tdmi")
4749 .Cases("armv5e", "armv5te", "arm1022e")
4750 .Cases("thumbv5e", "thumbv5te", "arm1022e")
4751 .Case("armv5tej", "arm926ej-s")
4752 .Case("thumbv5tej", "arm926ej-s")
4753 .Cases("armv6", "armv6k", "arm1136jf-s")
4754 .Cases("thumbv6", "thumbv6k", "arm1136jf-s")
4755 .Case("armv6j", "arm1136j-s")
4756 .Case("thumbv6j", "arm1136j-s")
4757 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
4758 .Cases("thumbv6z", "thumbv6zk", "arm1176jzf-s")
4759 .Case("armv6t2", "arm1156t2-s")
4760 .Case("thumbv6t2", "arm1156t2-s")
4761 .Cases("armv6m", "armv6-m", "cortex-m0")
4762 .Case("thumbv6m", "cortex-m0")
4763 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
4764 .Cases("thumbv7", "thumbv7a", "cortex-a8")
4765 .Cases("armv7l", "armv7-l", "cortex-a8")
Bernard Ogden31561762013-12-12 13:27:11 +00004766 .Cases("armv7s", "armv7-s", "swift")
4767 .Cases("armv7r", "armv7-r", "cortex-r4")
4768 .Case("thumbv7r", "cortex-r4")
4769 .Cases("armv7m", "armv7-m", "cortex-m3")
4770 .Case("thumbv7m", "cortex-m3")
4771 .Cases("armv7em", "armv7e-m", "cortex-m4")
4772 .Cases("thumbv7em", "thumbv7e-m", "cortex-m4")
4773 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
4774 .Cases("thumbv8", "thumbv8a", "cortex-a53")
4775 .Case("ep9312", "ep9312")
4776 .Case("iwmmxt", "iwmmxt")
4777 .Case("xscale", "xscale")
4778 // If all else failed, return the most base CPU with thumb interworking
4779 // supported by LLVM.
4780 .Default(0);
4781
4782 if (result)
4783 return result;
4784
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00004785 switch (Triple.getOS()) {
4786 case llvm::Triple::NetBSD:
4787 switch (Triple.getEnvironment()) {
4788 case llvm::Triple::GNUEABIHF:
4789 case llvm::Triple::GNUEABI:
4790 case llvm::Triple::EABIHF:
4791 case llvm::Triple::EABI:
4792 return "arm926ej-s";
4793 default:
4794 return "strongarm";
4795 }
4796 default:
4797 switch (Triple.getEnvironment()) {
4798 case llvm::Triple::EABIHF:
4799 case llvm::Triple::GNUEABIHF:
4800 return "arm1176jzf-s";
4801 default:
4802 return "arm7tdmi";
4803 }
4804 }
Bernard Ogden31561762013-12-12 13:27:11 +00004805}
4806
4807/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00004808StringRef arm::getARMTargetCPU(const ArgList &Args,
4809 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00004810 // FIXME: Warn on inconsistent use of -mcpu and -march.
4811 // If we have -mcpu=, use that.
4812 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
4813 StringRef MCPU = A->getValue();
4814 // Handle -mcpu=native.
4815 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00004816 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00004817 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00004818 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00004819 }
4820
4821 return getARMCPUForMArch(Args, Triple);
4822}
4823
4824/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
4825/// CPU.
4826//
4827// FIXME: This is redundant with -mcpu, why does LLVM use this.
4828// FIXME: tblgen this, or kill it!
4829const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
4830 return llvm::StringSwitch<const char *>(CPU)
4831 .Case("strongarm", "v4")
4832 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
4833 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
4834 .Cases("arm920", "arm920t", "arm922t", "v4t")
4835 .Cases("arm940t", "ep9312","v4t")
4836 .Cases("arm10tdmi", "arm1020t", "v5")
4837 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
4838 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
4839 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
4840 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
4841 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
4842 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00004843 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00004844 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
4845 .Cases("cortex-r4", "cortex-r5", "v7r")
4846 .Case("cortex-m0", "v6m")
4847 .Case("cortex-m3", "v7m")
4848 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00004849 .Case("swift", "v7s")
4850 .Cases("cortex-a53", "cortex-a57", "v8")
4851 .Default("");
4852}
4853
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004854bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
4855 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
4856 return A && (A->getValue() == StringRef(Value));
4857}
4858
Tim Northover157d9112014-01-16 08:48:16 +00004859llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004860 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4861 // archs which Darwin doesn't use.
4862
4863 // The matching this routine does is fairly pointless, since it is neither the
4864 // complete architecture list, nor a reasonable subset. The problem is that
4865 // historically the driver driver accepts this and also ties its -march=
4866 // handling to the architecture name, so we need to be careful before removing
4867 // support for it.
4868
4869 // This code must be kept in sync with Clang's Darwin specific argument
4870 // translation.
4871
4872 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4873 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4874 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4875 .Case("ppc64", llvm::Triple::ppc64)
4876 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4877 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4878 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00004879 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004880 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00004881 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00004882 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00004883 .Cases("armv7s", "xscale", llvm::Triple::arm)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004884 .Case("r600", llvm::Triple::r600)
4885 .Case("nvptx", llvm::Triple::nvptx)
4886 .Case("nvptx64", llvm::Triple::nvptx64)
4887 .Case("amdil", llvm::Triple::amdil)
4888 .Case("spir", llvm::Triple::spir)
4889 .Default(llvm::Triple::UnknownArch);
4890}
Tony Linthicum76329bf2011-12-12 21:14:55 +00004891
Tim Northover157d9112014-01-16 08:48:16 +00004892void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
4893 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
4894 T.setArch(Arch);
4895
4896 if (Str == "x86_64h")
4897 T.setArchName(Str);
4898 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
4899 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00004900 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00004901 }
4902}
4903
Bob Wilsondecc03e2012-11-23 06:14:39 +00004904const char *Clang::getBaseInputName(const ArgList &Args,
4905 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00004906 return Args.MakeArgString(
4907 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004908}
4909
Bob Wilsondecc03e2012-11-23 06:14:39 +00004910const char *Clang::getBaseInputStem(const ArgList &Args,
4911 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004912 const char *Str = getBaseInputName(Args, Inputs);
4913
Chris Lattner906bb902011-01-16 08:14:11 +00004914 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004915 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004916
4917 return Str;
4918}
4919
Bob Wilsondecc03e2012-11-23 06:14:39 +00004920const char *Clang::getDependencyFileName(const ArgList &Args,
4921 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004922 // FIXME: Think about this more.
4923 std::string Res;
4924
4925 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004926 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004927 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004928 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00004929 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004930 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004931 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004932}
4933
Daniel Dunbarbe220842009-03-20 16:06:39 +00004934void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004935 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004936 const InputInfoList &Inputs,
4937 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00004938 const char *LinkingOutput) const {
4939 ArgStringList CmdArgs;
4940
4941 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4942 const InputInfo &Input = Inputs[0];
4943
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004944 // Determine the original source input.
4945 const Action *SourceAction = &JA;
4946 while (SourceAction->getKind() != Action::InputClass) {
4947 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4948 SourceAction = SourceAction->getInputs()[0];
4949 }
4950
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004951 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00004952 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00004953 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
4954 // FIXME: at run-time detect assembler capabilities or rely on version
4955 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004956 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00004957 const llvm::Triple &T(getToolChain().getTriple());
4958 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00004959 CmdArgs.push_back("-Q");
4960 }
Kevin Enderby319baa42013-11-18 23:30:29 +00004961
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004962 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00004963 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004964 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004965 if (Args.hasArg(options::OPT_gstabs))
4966 CmdArgs.push_back("--gstabs");
4967 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00004968 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004969 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004970
Daniel Dunbarbe220842009-03-20 16:06:39 +00004971 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00004972 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00004973
Daniel Dunbar6d484762010-07-22 01:47:22 +00004974 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004975 if (getToolChain().getArch() == llvm::Triple::x86 ||
4976 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00004977 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4978 CmdArgs.push_back("-force_cpusubtype_ALL");
4979
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004980 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004981 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00004982 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00004983 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004984 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004985 CmdArgs.push_back("-static");
4986
Daniel Dunbarbe220842009-03-20 16:06:39 +00004987 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4988 options::OPT_Xassembler);
4989
4990 assert(Output.isFilename() && "Unexpected lipo output.");
4991 CmdArgs.push_back("-o");
4992 CmdArgs.push_back(Output.getFilename());
4993
Daniel Dunbarb440f562010-08-02 02:38:21 +00004994 assert(Input.isFilename() && "Invalid input.");
4995 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00004996
4997 // asm_final spec is empty.
4998
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004999 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005000 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005001 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005002}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005003
Tim Northover157d9112014-01-16 08:48:16 +00005004void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005005
Tim Northover157d9112014-01-16 08:48:16 +00005006void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5007 ArgStringList &CmdArgs) const {
5008 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005009
Daniel Dunbarc1964212009-03-26 16:23:12 +00005010 // Derived from darwin_arch spec.
5011 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005012 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005013
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005014 // FIXME: Is this needed anymore?
5015 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005016 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005017}
5018
Bill Wendling3b2000f2012-10-02 18:02:50 +00005019bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5020 // We only need to generate a temp path for LTO if we aren't compiling object
5021 // files. When compiling source files, we run 'dsymutil' after linking. We
5022 // don't run 'dsymutil' when compiling object files.
5023 for (InputInfoList::const_iterator
5024 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
5025 if (it->getType() != types::TY_Object)
5026 return true;
5027
5028 return false;
5029}
5030
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005031void darwin::Link::AddLinkArgs(Compilation &C,
5032 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005033 ArgStringList &CmdArgs,
5034 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005035 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005036 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005037
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005038 unsigned Version[3] = { 0, 0, 0 };
5039 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5040 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005041 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005042 Version[1], Version[2], HadExtra) ||
5043 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005044 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005045 << A->getAsString(Args);
5046 }
5047
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005048 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005049 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005050 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5051 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005052
Bob Wilson3d27dad2013-08-02 22:25:34 +00005053 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5054 CmdArgs.push_back("-export_dynamic");
5055
Bill Wendling313b6bf2012-11-16 23:03:00 +00005056 // If we are using LTO, then automatically create a temporary file path for
5057 // the linker to use, so that it's lifetime will extend past a possible
5058 // dsymutil step.
5059 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5060 const char *TmpPath = C.getArgs().MakeArgString(
5061 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5062 C.addTempFile(TmpPath);
5063 CmdArgs.push_back("-object_path_lto");
5064 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005065 }
5066
Daniel Dunbarc1964212009-03-26 16:23:12 +00005067 // Derived from the "link" spec.
5068 Args.AddAllArgs(CmdArgs, options::OPT_static);
5069 if (!Args.hasArg(options::OPT_static))
5070 CmdArgs.push_back("-dynamic");
5071 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5072 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5073 // here. How do we wish to handle such things?
5074 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005075
Daniel Dunbarc1964212009-03-26 16:23:12 +00005076 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005077 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005078 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005079 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005080
5081 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5082 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5083 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5084
5085 Arg *A;
5086 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5087 (A = Args.getLastArg(options::OPT_current__version)) ||
5088 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005089 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005090 << A->getAsString(Args) << "-dynamiclib";
5091
5092 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5093 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5094 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5095 } else {
5096 CmdArgs.push_back("-dylib");
5097
5098 Arg *A;
5099 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5100 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5101 (A = Args.getLastArg(options::OPT_client__name)) ||
5102 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5103 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5104 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005105 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005106 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005107
Daniel Dunbarc1964212009-03-26 16:23:12 +00005108 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5109 "-dylib_compatibility_version");
5110 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5111 "-dylib_current_version");
5112
Tim Northover157d9112014-01-16 08:48:16 +00005113 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005114
5115 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5116 "-dylib_install_name");
5117 }
5118
5119 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5120 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5121 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005122 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005123 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005124 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5125 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5126 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5127 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5128 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5129 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005130 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005131 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5132 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5133 Args.AddAllArgs(CmdArgs, options::OPT_init);
5134
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005135 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005136 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005137
Daniel Dunbarc1964212009-03-26 16:23:12 +00005138 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5139 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5140 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5141 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5142 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005143
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005144 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5145 options::OPT_fno_pie,
5146 options::OPT_fno_PIE)) {
5147 if (A->getOption().matches(options::OPT_fpie) ||
5148 A->getOption().matches(options::OPT_fPIE))
5149 CmdArgs.push_back("-pie");
5150 else
5151 CmdArgs.push_back("-no_pie");
5152 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005153
5154 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5155 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5156 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5157 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5158 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5159 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5160 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5161 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5162 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5163 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5164 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5165 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5166 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5167 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5168 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5169 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005170
Daniel Dunbar84384642011-05-02 21:03:47 +00005171 // Give --sysroot= preference, over the Apple specific behavior to also use
5172 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005173 StringRef sysroot = C.getSysRoot();
5174 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005175 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005176 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005177 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5178 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005179 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005180 }
5181
Daniel Dunbarc1964212009-03-26 16:23:12 +00005182 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5183 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5184 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5185 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5186 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005187 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005188 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5189 Args.AddAllArgs(CmdArgs, options::OPT_y);
5190 Args.AddLastArg(CmdArgs, options::OPT_w);
5191 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5192 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5193 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5194 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5195 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5196 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5197 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5198 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5199 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5200 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5201 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5202 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5203}
5204
Alexey Bataev186b28a2014-03-06 05:43:53 +00005205enum LibOpenMP {
5206 LibUnknown,
5207 LibGOMP,
5208 LibIOMP5
5209};
5210
Daniel Dunbarc1964212009-03-26 16:23:12 +00005211void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005212 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005213 const InputInfoList &Inputs,
5214 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005215 const char *LinkingOutput) const {
5216 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005217
Daniel Dunbarc1964212009-03-26 16:23:12 +00005218 // The logic here is derived from gcc's behavior; most of which
5219 // comes from specs (starting with link_command). Consult gcc for
5220 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005221 ArgStringList CmdArgs;
5222
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005223 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5224 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5225 options::OPT_ccc_arcmt_migrate)) {
5226 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
5227 (*I)->claim();
5228 const char *Exec =
5229 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5230 CmdArgs.push_back(Output.getFilename());
5231 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5232 return;
5233 }
5234
Daniel Dunbarc1964212009-03-26 16:23:12 +00005235 // I'm not sure why this particular decomposition exists in gcc, but
5236 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005237 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005238
Daniel Dunbarc1964212009-03-26 16:23:12 +00005239 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5240 Args.AddAllArgs(CmdArgs, options::OPT_s);
5241 Args.AddAllArgs(CmdArgs, options::OPT_t);
5242 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5243 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005244 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005245 Args.AddAllArgs(CmdArgs, options::OPT_r);
5246
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005247 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5248 // members of static archive libraries which implement Objective-C classes or
5249 // categories.
5250 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5251 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005252
Daniel Dunbarc1964212009-03-26 16:23:12 +00005253 CmdArgs.push_back("-o");
5254 CmdArgs.push_back(Output.getFilename());
5255
Chad Rosier06fd3c62012-05-16 23:45:12 +00005256 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005257 !Args.hasArg(options::OPT_nostartfiles))
5258 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005259
5260 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005261
Alexey Bataev186b28a2014-03-06 05:43:53 +00005262 LibOpenMP UsedOpenMPLib = LibUnknown;
5263 if (Args.hasArg(options::OPT_fopenmp)) {
5264 UsedOpenMPLib = LibGOMP;
5265 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5266 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5267 .Case("libgomp", LibGOMP)
5268 .Case("libiomp5", LibIOMP5)
5269 .Default(LibUnknown);
5270 if (UsedOpenMPLib == LibUnknown)
5271 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5272 << A->getOption().getName() << A->getValue();
5273 }
5274 switch (UsedOpenMPLib) {
5275 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005276 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005277 break;
5278 case LibIOMP5:
5279 CmdArgs.push_back("-liomp5");
5280 break;
5281 case LibUnknown:
5282 break;
5283 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005284
Douglas Gregor9295df02012-05-15 21:00:27 +00005285 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5286
Bob Wilson16d93952012-05-15 18:57:39 +00005287 if (isObjCRuntimeLinked(Args) &&
5288 !Args.hasArg(options::OPT_nostdlib) &&
5289 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005290 // We use arclite library for both ARC and subscripting support.
5291 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5292
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005293 CmdArgs.push_back("-framework");
5294 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005295 // Link libobj.
5296 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005297 }
John McCall31168b02011-06-15 23:02:42 +00005298
Daniel Dunbarc1964212009-03-26 16:23:12 +00005299 if (LinkingOutput) {
5300 CmdArgs.push_back("-arch_multiple");
5301 CmdArgs.push_back("-final_output");
5302 CmdArgs.push_back(LinkingOutput);
5303 }
5304
Daniel Dunbarc1964212009-03-26 16:23:12 +00005305 if (Args.hasArg(options::OPT_fnested_functions))
5306 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005307
Daniel Dunbarc1964212009-03-26 16:23:12 +00005308 if (!Args.hasArg(options::OPT_nostdlib) &&
5309 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005310 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005311 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005312
Daniel Dunbarc1964212009-03-26 16:23:12 +00005313 // link_ssp spec is empty.
5314
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005315 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005316 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005317 }
5318
Chad Rosier06fd3c62012-05-16 23:45:12 +00005319 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005320 !Args.hasArg(options::OPT_nostartfiles)) {
5321 // endfile_spec is empty.
5322 }
5323
5324 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5325 Args.AddAllArgs(CmdArgs, options::OPT_F);
5326
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005327 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005328 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005329 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005330}
5331
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005332void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005333 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005334 const InputInfoList &Inputs,
5335 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005336 const char *LinkingOutput) const {
5337 ArgStringList CmdArgs;
5338
5339 CmdArgs.push_back("-create");
5340 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005341
5342 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005343 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005344
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005345 for (InputInfoList::const_iterator
5346 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5347 const InputInfo &II = *it;
5348 assert(II.isFilename() && "Unexpected lipo input.");
5349 CmdArgs.push_back(II.getFilename());
5350 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005351 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005352 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005353 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005354}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005355
Daniel Dunbar88299622010-06-04 18:28:36 +00005356void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005357 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005358 const InputInfoList &Inputs,
5359 const ArgList &Args,
5360 const char *LinkingOutput) const {
5361 ArgStringList CmdArgs;
5362
Daniel Dunbareb86b042011-05-09 17:23:16 +00005363 CmdArgs.push_back("-o");
5364 CmdArgs.push_back(Output.getFilename());
5365
Daniel Dunbar88299622010-06-04 18:28:36 +00005366 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5367 const InputInfo &Input = Inputs[0];
5368 assert(Input.isFilename() && "Unexpected dsymutil input.");
5369 CmdArgs.push_back(Input.getFilename());
5370
Daniel Dunbar88299622010-06-04 18:28:36 +00005371 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005372 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005373 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005374}
5375
Eric Christopher551ef452011-08-23 17:56:55 +00005376void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005377 const InputInfo &Output,
5378 const InputInfoList &Inputs,
5379 const ArgList &Args,
5380 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005381 ArgStringList CmdArgs;
5382 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005383 CmdArgs.push_back("--debug-info");
5384 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005385 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005386
5387 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5388 const InputInfo &Input = Inputs[0];
5389 assert(Input.isFilename() && "Unexpected verify input");
5390
5391 // Grabbing the output of the earlier dsymutil run.
5392 CmdArgs.push_back(Input.getFilename());
5393
5394 const char *Exec =
5395 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5396 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5397}
5398
David Chisnallf571cde2012-02-15 13:39:01 +00005399void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5400 const InputInfo &Output,
5401 const InputInfoList &Inputs,
5402 const ArgList &Args,
5403 const char *LinkingOutput) const {
5404 ArgStringList CmdArgs;
5405
5406 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5407 options::OPT_Xassembler);
5408
5409 CmdArgs.push_back("-o");
5410 CmdArgs.push_back(Output.getFilename());
5411
5412 for (InputInfoList::const_iterator
5413 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5414 const InputInfo &II = *it;
5415 CmdArgs.push_back(II.getFilename());
5416 }
5417
5418 const char *Exec =
5419 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5420 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5421}
5422
5423
5424void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5425 const InputInfo &Output,
5426 const InputInfoList &Inputs,
5427 const ArgList &Args,
5428 const char *LinkingOutput) const {
5429 // FIXME: Find a real GCC, don't hard-code versions here
5430 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5431 const llvm::Triple &T = getToolChain().getTriple();
5432 std::string LibPath = "/usr/lib/";
5433 llvm::Triple::ArchType Arch = T.getArch();
5434 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005435 case llvm::Triple::x86:
5436 GCCLibPath +=
5437 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5438 break;
5439 case llvm::Triple::x86_64:
5440 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5441 GCCLibPath += "/4.5.2/amd64/";
5442 LibPath += "amd64/";
5443 break;
5444 default:
5445 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005446 }
5447
5448 ArgStringList CmdArgs;
5449
David Chisnall272a0712012-02-29 15:06:12 +00005450 // Demangle C++ names in errors
5451 CmdArgs.push_back("-C");
5452
David Chisnallf571cde2012-02-15 13:39:01 +00005453 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5454 (!Args.hasArg(options::OPT_shared))) {
5455 CmdArgs.push_back("-e");
5456 CmdArgs.push_back("_start");
5457 }
5458
5459 if (Args.hasArg(options::OPT_static)) {
5460 CmdArgs.push_back("-Bstatic");
5461 CmdArgs.push_back("-dn");
5462 } else {
5463 CmdArgs.push_back("-Bdynamic");
5464 if (Args.hasArg(options::OPT_shared)) {
5465 CmdArgs.push_back("-shared");
5466 } else {
5467 CmdArgs.push_back("--dynamic-linker");
5468 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5469 }
5470 }
5471
5472 if (Output.isFilename()) {
5473 CmdArgs.push_back("-o");
5474 CmdArgs.push_back(Output.getFilename());
5475 } else {
5476 assert(Output.isNothing() && "Invalid output.");
5477 }
5478
5479 if (!Args.hasArg(options::OPT_nostdlib) &&
5480 !Args.hasArg(options::OPT_nostartfiles)) {
5481 if (!Args.hasArg(options::OPT_shared)) {
5482 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5483 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005484 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005485 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5486 } else {
5487 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005488 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5489 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005490 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005491 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005492 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005493 }
5494
5495 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5496
5497 Args.AddAllArgs(CmdArgs, options::OPT_L);
5498 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5499 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005500 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005501
5502 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5503
5504 if (!Args.hasArg(options::OPT_nostdlib) &&
5505 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005506 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005507 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005508 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005509 if (!Args.hasArg(options::OPT_shared)) {
5510 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005511 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005512 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005513 }
David Chisnallf571cde2012-02-15 13:39:01 +00005514 }
5515
5516 if (!Args.hasArg(options::OPT_nostdlib) &&
5517 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005518 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005519 }
David Chisnall96de9932012-02-16 16:00:47 +00005520 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005521
Alexey Samsonov7811d192014-02-20 13:57:37 +00005522 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005523
5524 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005525 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005526 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5527}
5528
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005529void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005530 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005531 const InputInfoList &Inputs,
5532 const ArgList &Args,
5533 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005534 ArgStringList CmdArgs;
5535
5536 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5537 options::OPT_Xassembler);
5538
5539 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005540 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005541
5542 for (InputInfoList::const_iterator
5543 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5544 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005545 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005546 }
5547
5548 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005549 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005550 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005551}
5552
5553void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005554 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005555 const InputInfoList &Inputs,
5556 const ArgList &Args,
5557 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005558 ArgStringList CmdArgs;
5559
5560 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005561 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005562 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005563 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005564 }
5565
5566 if (Args.hasArg(options::OPT_static)) {
5567 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005568 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005569 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005570// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005571 CmdArgs.push_back("-Bdynamic");
5572 if (Args.hasArg(options::OPT_shared)) {
5573 CmdArgs.push_back("-shared");
5574 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005575 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005576 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5577 }
5578 }
5579
Daniel Dunbarb440f562010-08-02 02:38:21 +00005580 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005581 CmdArgs.push_back("-o");
5582 CmdArgs.push_back(Output.getFilename());
5583 } else {
5584 assert(Output.isNothing() && "Invalid output.");
5585 }
5586
5587 if (!Args.hasArg(options::OPT_nostdlib) &&
5588 !Args.hasArg(options::OPT_nostartfiles)) {
5589 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005590 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005591 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005592 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005593 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005594 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005595 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005596 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005597 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005598 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005599 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005600 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005601 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005602 }
5603
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005604 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5605 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005606 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005607
5608 Args.AddAllArgs(CmdArgs, options::OPT_L);
5609 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5610 Args.AddAllArgs(CmdArgs, options::OPT_e);
5611
Daniel Dunbar54423b22010-09-17 00:24:54 +00005612 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005613
5614 if (!Args.hasArg(options::OPT_nostdlib) &&
5615 !Args.hasArg(options::OPT_nodefaultlibs)) {
5616 // FIXME: For some reason GCC passes -lgcc before adding
5617 // the default system libraries. Just mimic this for now.
5618 CmdArgs.push_back("-lgcc");
5619
5620 if (Args.hasArg(options::OPT_pthread))
5621 CmdArgs.push_back("-pthread");
5622 if (!Args.hasArg(options::OPT_shared))
5623 CmdArgs.push_back("-lc");
5624 CmdArgs.push_back("-lgcc");
5625 }
5626
5627 if (!Args.hasArg(options::OPT_nostdlib) &&
5628 !Args.hasArg(options::OPT_nostartfiles)) {
5629 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005630 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005631 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005632 }
5633
Alexey Samsonov7811d192014-02-20 13:57:37 +00005634 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005635
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005636 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005637 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005638 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005639}
5640
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005641void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005642 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005643 const InputInfoList &Inputs,
5644 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005645 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005646 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005647 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005648
Rafael Espindolacc126272014-02-28 01:55:21 +00005649 switch (getToolChain().getArch()) {
5650 case llvm::Triple::x86:
5651 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5652 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005653 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005654 break;
5655
5656 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005657 CmdArgs.push_back("-mppc");
5658 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005659 break;
5660
5661 case llvm::Triple::sparc:
5662 CmdArgs.push_back("-32");
5663 NeedsKPIC = true;
5664 break;
5665
5666 case llvm::Triple::sparcv9:
5667 CmdArgs.push_back("-64");
5668 CmdArgs.push_back("-Av9a");
5669 NeedsKPIC = true;
5670 break;
5671
5672 case llvm::Triple::mips64:
5673 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005674 StringRef CPUName;
5675 StringRef ABIName;
5676 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5677
5678 CmdArgs.push_back("-mabi");
5679 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5680
5681 if (getToolChain().getArch() == llvm::Triple::mips64)
5682 CmdArgs.push_back("-EB");
5683 else
5684 CmdArgs.push_back("-EL");
5685
Rafael Espindolacc126272014-02-28 01:55:21 +00005686 NeedsKPIC = true;
5687 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005688 }
5689
Rafael Espindolacc126272014-02-28 01:55:21 +00005690 default:
5691 break;
5692 }
5693
5694 if (NeedsKPIC)
5695 addAssemblerKPIC(Args, CmdArgs);
5696
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005697 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5698 options::OPT_Xassembler);
5699
5700 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005701 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005702
5703 for (InputInfoList::const_iterator
5704 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5705 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005706 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005707 }
5708
5709 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005710 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005711 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005712}
5713
5714void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005715 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005716 const InputInfoList &Inputs,
5717 const ArgList &Args,
5718 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005719 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005720 ArgStringList CmdArgs;
5721
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005722 // Silence warning for "clang -g foo.o -o foo"
5723 Args.ClaimAllArgs(options::OPT_g_Group);
5724 // and "clang -emit-llvm foo.o -o foo"
5725 Args.ClaimAllArgs(options::OPT_emit_llvm);
5726 // and for "clang -w foo.o -o foo". Other warning options are already
5727 // handled somewhere else.
5728 Args.ClaimAllArgs(options::OPT_w);
5729
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005730 if (getToolChain().getArch() == llvm::Triple::mips64)
5731 CmdArgs.push_back("-EB");
5732 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5733 CmdArgs.push_back("-EL");
5734
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005735 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005736 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005737 CmdArgs.push_back("-e");
5738 CmdArgs.push_back("__start");
5739 }
5740
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005741 if (Args.hasArg(options::OPT_static)) {
5742 CmdArgs.push_back("-Bstatic");
5743 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005744 if (Args.hasArg(options::OPT_rdynamic))
5745 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005746 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005747 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005748 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005749 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005750 } else {
5751 CmdArgs.push_back("-dynamic-linker");
5752 CmdArgs.push_back("/usr/libexec/ld.so");
5753 }
5754 }
5755
Rafael Espindola044f7832013-06-05 04:28:55 +00005756 if (Args.hasArg(options::OPT_nopie))
5757 CmdArgs.push_back("-nopie");
5758
Daniel Dunbarb440f562010-08-02 02:38:21 +00005759 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005760 CmdArgs.push_back("-o");
5761 CmdArgs.push_back(Output.getFilename());
5762 } else {
5763 assert(Output.isNothing() && "Invalid output.");
5764 }
5765
5766 if (!Args.hasArg(options::OPT_nostdlib) &&
5767 !Args.hasArg(options::OPT_nostartfiles)) {
5768 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00005769 if (Args.hasArg(options::OPT_pg))
5770 CmdArgs.push_back(Args.MakeArgString(
5771 getToolChain().GetFilePath("gcrt0.o")));
5772 else
5773 CmdArgs.push_back(Args.MakeArgString(
5774 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005775 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005776 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005777 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005778 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005779 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005780 }
5781 }
5782
Edward O'Callaghan5c521462009-10-28 15:13:08 +00005783 std::string Triple = getToolChain().getTripleString();
5784 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005785 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005786 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005787 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005788
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005789 Args.AddAllArgs(CmdArgs, options::OPT_L);
5790 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5791 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005792 Args.AddAllArgs(CmdArgs, options::OPT_s);
5793 Args.AddAllArgs(CmdArgs, options::OPT_t);
5794 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5795 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005796
Daniel Dunbar54423b22010-09-17 00:24:54 +00005797 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005798
5799 if (!Args.hasArg(options::OPT_nostdlib) &&
5800 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005801 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005802 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00005803 if (Args.hasArg(options::OPT_pg))
5804 CmdArgs.push_back("-lm_p");
5805 else
5806 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005807 }
5808
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005809 // FIXME: For some reason GCC passes -lgcc before adding
5810 // the default system libraries. Just mimic this for now.
5811 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005812
Eric Christopher17674ec2012-09-13 06:32:34 +00005813 if (Args.hasArg(options::OPT_pthread)) {
5814 if (!Args.hasArg(options::OPT_shared) &&
5815 Args.hasArg(options::OPT_pg))
5816 CmdArgs.push_back("-lpthread_p");
5817 else
5818 CmdArgs.push_back("-lpthread");
5819 }
5820
Chandler Carruth45661652011-12-17 22:32:42 +00005821 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00005822 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00005823 CmdArgs.push_back("-lc_p");
5824 else
5825 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00005826 }
Eric Christopher17674ec2012-09-13 06:32:34 +00005827
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005828 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005829 }
5830
5831 if (!Args.hasArg(options::OPT_nostdlib) &&
5832 !Args.hasArg(options::OPT_nostartfiles)) {
5833 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005834 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005835 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005836 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005837 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005838 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005839 }
5840
5841 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005842 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005843 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005844}
Ed Schoutene33194b2009-04-02 19:13:12 +00005845
Eli Friedman9fa28852012-08-08 23:57:20 +00005846void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5847 const InputInfo &Output,
5848 const InputInfoList &Inputs,
5849 const ArgList &Args,
5850 const char *LinkingOutput) const {
5851 ArgStringList CmdArgs;
5852
5853 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5854 options::OPT_Xassembler);
5855
5856 CmdArgs.push_back("-o");
5857 CmdArgs.push_back(Output.getFilename());
5858
5859 for (InputInfoList::const_iterator
5860 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5861 const InputInfo &II = *it;
5862 CmdArgs.push_back(II.getFilename());
5863 }
5864
5865 const char *Exec =
5866 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5867 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5868}
5869
5870void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5871 const InputInfo &Output,
5872 const InputInfoList &Inputs,
5873 const ArgList &Args,
5874 const char *LinkingOutput) const {
5875 const Driver &D = getToolChain().getDriver();
5876 ArgStringList CmdArgs;
5877
5878 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5879 (!Args.hasArg(options::OPT_shared))) {
5880 CmdArgs.push_back("-e");
5881 CmdArgs.push_back("__start");
5882 }
5883
5884 if (Args.hasArg(options::OPT_static)) {
5885 CmdArgs.push_back("-Bstatic");
5886 } else {
5887 if (Args.hasArg(options::OPT_rdynamic))
5888 CmdArgs.push_back("-export-dynamic");
5889 CmdArgs.push_back("--eh-frame-hdr");
5890 CmdArgs.push_back("-Bdynamic");
5891 if (Args.hasArg(options::OPT_shared)) {
5892 CmdArgs.push_back("-shared");
5893 } else {
5894 CmdArgs.push_back("-dynamic-linker");
5895 CmdArgs.push_back("/usr/libexec/ld.so");
5896 }
5897 }
5898
5899 if (Output.isFilename()) {
5900 CmdArgs.push_back("-o");
5901 CmdArgs.push_back(Output.getFilename());
5902 } else {
5903 assert(Output.isNothing() && "Invalid output.");
5904 }
5905
5906 if (!Args.hasArg(options::OPT_nostdlib) &&
5907 !Args.hasArg(options::OPT_nostartfiles)) {
5908 if (!Args.hasArg(options::OPT_shared)) {
5909 if (Args.hasArg(options::OPT_pg))
5910 CmdArgs.push_back(Args.MakeArgString(
5911 getToolChain().GetFilePath("gcrt0.o")));
5912 else
5913 CmdArgs.push_back(Args.MakeArgString(
5914 getToolChain().GetFilePath("crt0.o")));
5915 CmdArgs.push_back(Args.MakeArgString(
5916 getToolChain().GetFilePath("crtbegin.o")));
5917 } else {
5918 CmdArgs.push_back(Args.MakeArgString(
5919 getToolChain().GetFilePath("crtbeginS.o")));
5920 }
5921 }
5922
5923 Args.AddAllArgs(CmdArgs, options::OPT_L);
5924 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5925 Args.AddAllArgs(CmdArgs, options::OPT_e);
5926
5927 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5928
5929 if (!Args.hasArg(options::OPT_nostdlib) &&
5930 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005931 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00005932 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5933 if (Args.hasArg(options::OPT_pg))
5934 CmdArgs.push_back("-lm_p");
5935 else
5936 CmdArgs.push_back("-lm");
5937 }
5938
Rafael Espindola1ad26f02012-10-23 17:07:31 +00005939 if (Args.hasArg(options::OPT_pthread)) {
5940 if (!Args.hasArg(options::OPT_shared) &&
5941 Args.hasArg(options::OPT_pg))
5942 CmdArgs.push_back("-lpthread_p");
5943 else
5944 CmdArgs.push_back("-lpthread");
5945 }
5946
Eli Friedman9fa28852012-08-08 23:57:20 +00005947 if (!Args.hasArg(options::OPT_shared)) {
5948 if (Args.hasArg(options::OPT_pg))
5949 CmdArgs.push_back("-lc_p");
5950 else
5951 CmdArgs.push_back("-lc");
5952 }
5953
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005954 StringRef MyArch;
5955 switch (getToolChain().getTriple().getArch()) {
5956 case llvm::Triple::arm:
5957 MyArch = "arm";
5958 break;
5959 case llvm::Triple::x86:
5960 MyArch = "i386";
5961 break;
5962 case llvm::Triple::x86_64:
5963 MyArch = "amd64";
5964 break;
5965 default:
5966 llvm_unreachable("Unsupported architecture");
5967 }
5968 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00005969 }
5970
5971 if (!Args.hasArg(options::OPT_nostdlib) &&
5972 !Args.hasArg(options::OPT_nostartfiles)) {
5973 if (!Args.hasArg(options::OPT_shared))
5974 CmdArgs.push_back(Args.MakeArgString(
5975 getToolChain().GetFilePath("crtend.o")));
5976 else
5977 CmdArgs.push_back(Args.MakeArgString(
5978 getToolChain().GetFilePath("crtendS.o")));
5979 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005980
5981 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005982 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005983 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00005984}
5985
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005986void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005987 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005988 const InputInfoList &Inputs,
5989 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005990 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005991 ArgStringList CmdArgs;
5992
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005993 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5994 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005995 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005996 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005997 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00005998 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005999 else if (getToolChain().getArch() == llvm::Triple::mips ||
6000 getToolChain().getArch() == llvm::Triple::mipsel ||
6001 getToolChain().getArch() == llvm::Triple::mips64 ||
6002 getToolChain().getArch() == llvm::Triple::mips64el) {
6003 StringRef CPUName;
6004 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006005 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006006
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006007 CmdArgs.push_back("-march");
6008 CmdArgs.push_back(CPUName.data());
6009
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006010 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006011 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006012
6013 if (getToolChain().getArch() == llvm::Triple::mips ||
6014 getToolChain().getArch() == llvm::Triple::mips64)
6015 CmdArgs.push_back("-EB");
6016 else
6017 CmdArgs.push_back("-EL");
6018
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006019 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006020 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6021 getToolChain().getArch() == llvm::Triple::thumb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006022 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006023 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006024 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6025
6026 if (FloatABI == "hard") {
6027 CmdArgs.push_back("-mfpu=vfp");
6028 } else {
6029 CmdArgs.push_back("-mfpu=softvfp");
6030 }
6031
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006032 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006033 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006034 case llvm::Triple::GNUEABI:
6035 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006036 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006037 break;
6038
6039 default:
6040 CmdArgs.push_back("-matpcs");
6041 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006042 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006043 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006044 if (getToolChain().getArch() == llvm::Triple::sparc)
6045 CmdArgs.push_back("-Av8plusa");
6046 else
6047 CmdArgs.push_back("-Av9a");
6048
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006049 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006050 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006051
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006052 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6053 options::OPT_Xassembler);
6054
6055 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006056 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006057
6058 for (InputInfoList::const_iterator
6059 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6060 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006061 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006062 }
6063
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006064 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006065 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006066 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006067}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006068
6069void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006070 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006071 const InputInfoList &Inputs,
6072 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006073 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006074 const toolchains::FreeBSD& ToolChain =
6075 static_cast<const toolchains::FreeBSD&>(getToolChain());
6076 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006077 const bool IsPIE =
6078 !Args.hasArg(options::OPT_shared) &&
6079 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006080 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006081
6082 // Silence warning for "clang -g foo.o -o foo"
6083 Args.ClaimAllArgs(options::OPT_g_Group);
6084 // and "clang -emit-llvm foo.o -o foo"
6085 Args.ClaimAllArgs(options::OPT_emit_llvm);
6086 // and for "clang -w foo.o -o foo". Other warning options are already
6087 // handled somewhere else.
6088 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006089
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006090 if (!D.SysRoot.empty())
6091 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6092
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006093 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006094 CmdArgs.push_back("-pie");
6095
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006096 if (Args.hasArg(options::OPT_static)) {
6097 CmdArgs.push_back("-Bstatic");
6098 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006099 if (Args.hasArg(options::OPT_rdynamic))
6100 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006101 CmdArgs.push_back("--eh-frame-hdr");
6102 if (Args.hasArg(options::OPT_shared)) {
6103 CmdArgs.push_back("-Bshareable");
6104 } else {
6105 CmdArgs.push_back("-dynamic-linker");
6106 CmdArgs.push_back("/libexec/ld-elf.so.1");
6107 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006108 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6109 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006110 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6111 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6112 CmdArgs.push_back("--hash-style=both");
6113 }
6114 }
6115 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006116 }
6117
6118 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6119 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006120 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006121 CmdArgs.push_back("-m");
6122 CmdArgs.push_back("elf_i386_fbsd");
6123 }
6124
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006125 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006126 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006127 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006128 }
6129
Daniel Dunbarb440f562010-08-02 02:38:21 +00006130 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006131 CmdArgs.push_back("-o");
6132 CmdArgs.push_back(Output.getFilename());
6133 } else {
6134 assert(Output.isNothing() && "Invalid output.");
6135 }
6136
6137 if (!Args.hasArg(options::OPT_nostdlib) &&
6138 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006139 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006140 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006141 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006142 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006143 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006144 crt1 = "Scrt1.o";
6145 else
6146 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006147 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006148 if (crt1)
6149 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6150
6151 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6152
6153 const char *crtbegin = NULL;
6154 if (Args.hasArg(options::OPT_static))
6155 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006156 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006157 crtbegin = "crtbeginS.o";
6158 else
6159 crtbegin = "crtbegin.o";
6160
6161 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006162 }
6163
6164 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006165 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00006166 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6167 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006168 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006169 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6170 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006171 Args.AddAllArgs(CmdArgs, options::OPT_s);
6172 Args.AddAllArgs(CmdArgs, options::OPT_t);
6173 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6174 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006175
Alp Tokerce365ca2013-12-02 12:43:03 +00006176 if (D.IsUsingLTO(Args))
6177 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006178
Roman Divackyafe2f232012-08-28 15:09:03 +00006179 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006180
6181 if (!Args.hasArg(options::OPT_nostdlib) &&
6182 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006183 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006184 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006185 if (Args.hasArg(options::OPT_pg))
6186 CmdArgs.push_back("-lm_p");
6187 else
6188 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006189 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006190 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6191 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006192 if (Args.hasArg(options::OPT_pg))
6193 CmdArgs.push_back("-lgcc_p");
6194 else
6195 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006196 if (Args.hasArg(options::OPT_static)) {
6197 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006198 } else if (Args.hasArg(options::OPT_pg)) {
6199 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006200 } else {
6201 CmdArgs.push_back("--as-needed");
6202 CmdArgs.push_back("-lgcc_s");
6203 CmdArgs.push_back("--no-as-needed");
6204 }
6205
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006206 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006207 if (Args.hasArg(options::OPT_pg))
6208 CmdArgs.push_back("-lpthread_p");
6209 else
6210 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006211 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006212
Roman Divacky66f22762011-02-10 16:59:40 +00006213 if (Args.hasArg(options::OPT_pg)) {
6214 if (Args.hasArg(options::OPT_shared))
6215 CmdArgs.push_back("-lc");
6216 else
6217 CmdArgs.push_back("-lc_p");
6218 CmdArgs.push_back("-lgcc_p");
6219 } else {
6220 CmdArgs.push_back("-lc");
6221 CmdArgs.push_back("-lgcc");
6222 }
6223
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006224 if (Args.hasArg(options::OPT_static)) {
6225 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006226 } else if (Args.hasArg(options::OPT_pg)) {
6227 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006228 } else {
6229 CmdArgs.push_back("--as-needed");
6230 CmdArgs.push_back("-lgcc_s");
6231 CmdArgs.push_back("--no-as-needed");
6232 }
6233 }
6234
6235 if (!Args.hasArg(options::OPT_nostdlib) &&
6236 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006237 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006238 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006239 else
6240 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006241 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006242 }
6243
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006244 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6245
Alexey Samsonov7811d192014-02-20 13:57:37 +00006246 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006247
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006248 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006249 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006250 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006251}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006252
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006253void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6254 const InputInfo &Output,
6255 const InputInfoList &Inputs,
6256 const ArgList &Args,
6257 const char *LinkingOutput) const {
6258 ArgStringList CmdArgs;
6259
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006260 // GNU as needs different flags for creating the correct output format
6261 // on architectures with different ABIs or optional feature sets.
6262 switch (getToolChain().getArch()) {
6263 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006264 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006265 break;
6266 case llvm::Triple::arm:
6267 case llvm::Triple::thumb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006268 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006269 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006270 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006271 }
6272
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006273 case llvm::Triple::mips:
6274 case llvm::Triple::mipsel:
6275 case llvm::Triple::mips64:
6276 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006277 StringRef CPUName;
6278 StringRef ABIName;
6279 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6280
6281 CmdArgs.push_back("-march");
6282 CmdArgs.push_back(CPUName.data());
6283
6284 CmdArgs.push_back("-mabi");
6285 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6286
6287 if (getToolChain().getArch() == llvm::Triple::mips ||
6288 getToolChain().getArch() == llvm::Triple::mips64)
6289 CmdArgs.push_back("-EB");
6290 else
6291 CmdArgs.push_back("-EL");
6292
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006293 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006294 break;
6295 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006296
6297 case llvm::Triple::sparc:
6298 CmdArgs.push_back("-32");
6299 addAssemblerKPIC(Args, CmdArgs);
6300 break;
6301
6302 case llvm::Triple::sparcv9:
6303 CmdArgs.push_back("-64");
6304 CmdArgs.push_back("-Av9");
6305 addAssemblerKPIC(Args, CmdArgs);
6306 break;
6307
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006308 default:
6309 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006310 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006311
6312 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6313 options::OPT_Xassembler);
6314
6315 CmdArgs.push_back("-o");
6316 CmdArgs.push_back(Output.getFilename());
6317
6318 for (InputInfoList::const_iterator
6319 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6320 const InputInfo &II = *it;
6321 CmdArgs.push_back(II.getFilename());
6322 }
6323
David Chisnallddbd68f2011-09-27 22:03:18 +00006324 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006325 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6326}
6327
6328void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6329 const InputInfo &Output,
6330 const InputInfoList &Inputs,
6331 const ArgList &Args,
6332 const char *LinkingOutput) const {
6333 const Driver &D = getToolChain().getDriver();
6334 ArgStringList CmdArgs;
6335
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006336 if (!D.SysRoot.empty())
6337 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6338
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006339 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006340 if (Args.hasArg(options::OPT_static)) {
6341 CmdArgs.push_back("-Bstatic");
6342 } else {
6343 if (Args.hasArg(options::OPT_rdynamic))
6344 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006345 if (Args.hasArg(options::OPT_shared)) {
6346 CmdArgs.push_back("-Bshareable");
6347 } else {
6348 CmdArgs.push_back("-dynamic-linker");
6349 CmdArgs.push_back("/libexec/ld.elf_so");
6350 }
6351 }
6352
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006353 // Many NetBSD architectures support more than one ABI.
6354 // Determine the correct emulation for ld.
6355 switch (getToolChain().getArch()) {
6356 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006357 CmdArgs.push_back("-m");
6358 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006359 break;
6360 case llvm::Triple::arm:
6361 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006362 CmdArgs.push_back("-m");
6363 switch (getToolChain().getTriple().getEnvironment()) {
6364 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006365 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006366 CmdArgs.push_back("armelf_nbsd_eabi");
6367 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006368 case llvm::Triple::EABIHF:
6369 case llvm::Triple::GNUEABIHF:
6370 CmdArgs.push_back("armelf_nbsd_eabihf");
6371 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006372 default:
6373 CmdArgs.push_back("armelf_nbsd");
6374 break;
6375 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006376 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006377 case llvm::Triple::mips64:
6378 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006379 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006380 CmdArgs.push_back("-m");
6381 if (getToolChain().getArch() == llvm::Triple::mips64)
6382 CmdArgs.push_back("elf32btsmip");
6383 else
6384 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006385 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006386 CmdArgs.push_back("-m");
6387 if (getToolChain().getArch() == llvm::Triple::mips64)
6388 CmdArgs.push_back("elf64btsmip");
6389 else
6390 CmdArgs.push_back("elf64ltsmip");
6391 }
6392 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006393
6394 case llvm::Triple::sparc:
6395 CmdArgs.push_back("-m");
6396 CmdArgs.push_back("elf32_sparc");
6397 break;
6398
6399 case llvm::Triple::sparcv9:
6400 CmdArgs.push_back("-m");
6401 CmdArgs.push_back("elf64_sparc");
6402 break;
6403
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006404 default:
6405 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006406 }
6407
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006408 if (Output.isFilename()) {
6409 CmdArgs.push_back("-o");
6410 CmdArgs.push_back(Output.getFilename());
6411 } else {
6412 assert(Output.isNothing() && "Invalid output.");
6413 }
6414
6415 if (!Args.hasArg(options::OPT_nostdlib) &&
6416 !Args.hasArg(options::OPT_nostartfiles)) {
6417 if (!Args.hasArg(options::OPT_shared)) {
6418 CmdArgs.push_back(Args.MakeArgString(
6419 getToolChain().GetFilePath("crt0.o")));
6420 CmdArgs.push_back(Args.MakeArgString(
6421 getToolChain().GetFilePath("crti.o")));
6422 CmdArgs.push_back(Args.MakeArgString(
6423 getToolChain().GetFilePath("crtbegin.o")));
6424 } else {
6425 CmdArgs.push_back(Args.MakeArgString(
6426 getToolChain().GetFilePath("crti.o")));
6427 CmdArgs.push_back(Args.MakeArgString(
6428 getToolChain().GetFilePath("crtbeginS.o")));
6429 }
6430 }
6431
6432 Args.AddAllArgs(CmdArgs, options::OPT_L);
6433 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6434 Args.AddAllArgs(CmdArgs, options::OPT_e);
6435 Args.AddAllArgs(CmdArgs, options::OPT_s);
6436 Args.AddAllArgs(CmdArgs, options::OPT_t);
6437 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6438 Args.AddAllArgs(CmdArgs, options::OPT_r);
6439
6440 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6441
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006442 unsigned Major, Minor, Micro;
6443 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6444 bool useLibgcc = true;
6445 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006446 switch(getToolChain().getArch()) {
6447 case llvm::Triple::x86:
6448 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006449 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006450 break;
6451 default:
6452 break;
6453 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006454 }
6455
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006456 if (!Args.hasArg(options::OPT_nostdlib) &&
6457 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006458 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006459 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6460 CmdArgs.push_back("-lm");
6461 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006462 if (Args.hasArg(options::OPT_pthread))
6463 CmdArgs.push_back("-lpthread");
6464 CmdArgs.push_back("-lc");
6465
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006466 if (useLibgcc) {
6467 if (Args.hasArg(options::OPT_static)) {
6468 // libgcc_eh depends on libc, so resolve as much as possible,
6469 // pull in any new requirements from libc and then get the rest
6470 // of libgcc.
6471 CmdArgs.push_back("-lgcc_eh");
6472 CmdArgs.push_back("-lc");
6473 CmdArgs.push_back("-lgcc");
6474 } else {
6475 CmdArgs.push_back("-lgcc");
6476 CmdArgs.push_back("--as-needed");
6477 CmdArgs.push_back("-lgcc_s");
6478 CmdArgs.push_back("--no-as-needed");
6479 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006480 }
6481 }
6482
6483 if (!Args.hasArg(options::OPT_nostdlib) &&
6484 !Args.hasArg(options::OPT_nostartfiles)) {
6485 if (!Args.hasArg(options::OPT_shared))
6486 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6487 "crtend.o")));
6488 else
6489 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6490 "crtendS.o")));
6491 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6492 "crtn.o")));
6493 }
6494
Alexey Samsonov7811d192014-02-20 13:57:37 +00006495 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006496
Rafael Espindola236db462013-11-09 20:07:19 +00006497 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006498 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6499}
6500
Thomas Schwinge4e555262013-03-28 19:04:25 +00006501void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6502 const InputInfo &Output,
6503 const InputInfoList &Inputs,
6504 const ArgList &Args,
6505 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006506 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006507 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006508
6509 // Add --32/--64 to make sure we get the format we want.
6510 // This is incomplete
6511 if (getToolChain().getArch() == llvm::Triple::x86) {
6512 CmdArgs.push_back("--32");
6513 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6514 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006515 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6516 CmdArgs.push_back("-a32");
6517 CmdArgs.push_back("-mppc");
6518 CmdArgs.push_back("-many");
6519 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6520 CmdArgs.push_back("-a64");
6521 CmdArgs.push_back("-mppc64");
6522 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006523 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6524 CmdArgs.push_back("-a64");
6525 CmdArgs.push_back("-mppc64le");
6526 CmdArgs.push_back("-many");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006527 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6528 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006529 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006530 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006531 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6532 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006533 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006534 NeedsKPIC = true;
Rafael Espindola92b00932010-08-10 00:25:48 +00006535 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006536 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006537 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6538 CmdArgs.push_back("-mfpu=neon");
Bernard Ogdena58ef052013-10-24 18:32:41 +00006539 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6540 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006541
Tim Northover9c7e0352013-12-12 11:55:52 +00006542 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6543 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006544 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006545
6546 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006547
6548 // FIXME: remove krait check when GNU tools support krait cpu
6549 // for now replace it with -march=armv7-a to avoid a lower
6550 // march from being picked in the absence of a cpu flag.
6551 Arg *A;
6552 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6553 StringRef(A->getValue()) == "krait")
6554 CmdArgs.push_back("-march=armv7-a");
6555 else
6556 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006557 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006558 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6559 getToolChain().getArch() == llvm::Triple::mipsel ||
6560 getToolChain().getArch() == llvm::Triple::mips64 ||
6561 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006562 StringRef CPUName;
6563 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006564 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006565
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006566 CmdArgs.push_back("-march");
6567 CmdArgs.push_back(CPUName.data());
6568
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006569 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006570 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006571
6572 if (getToolChain().getArch() == llvm::Triple::mips ||
6573 getToolChain().getArch() == llvm::Triple::mips64)
6574 CmdArgs.push_back("-EB");
6575 else
6576 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006577
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006578 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6579 if (StringRef(A->getValue()) == "2008")
6580 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6581 }
6582
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006583 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006584 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6585 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6586 options::OPT_mno_micromips);
6587 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6588 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6589
Simon Atanasyanbd986632013-11-26 11:58:04 +00006590 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6591 // Do not use AddLastArg because not all versions of MIPS assembler
6592 // support -mmsa / -mno-msa options.
6593 if (A->getOption().matches(options::OPT_mmsa))
6594 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6595 }
6596
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006597 NeedsKPIC = true;
6598 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6599 // Always pass an -march option, since our default of z10 is later
6600 // than the GNU assembler's default.
6601 StringRef CPUName = getSystemZTargetCPU(Args);
6602 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6603 }
6604
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006605 if (NeedsKPIC)
6606 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006607
6608 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6609 options::OPT_Xassembler);
6610
6611 CmdArgs.push_back("-o");
6612 CmdArgs.push_back(Output.getFilename());
6613
6614 for (InputInfoList::const_iterator
6615 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6616 const InputInfo &II = *it;
6617 CmdArgs.push_back(II.getFilename());
6618 }
6619
6620 const char *Exec =
6621 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6622 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006623
6624 // Handle the debug info splitting at object creation time if we're
6625 // creating an object.
6626 // TODO: Currently only works on linux with newer objcopy.
6627 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006628 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006629 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6630 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006631}
6632
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006633static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006634 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006635 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006636 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6637 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006638 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006639 CmdArgs.push_back("-lgcc");
6640
Logan Chien3d3373c2012-11-19 12:04:11 +00006641 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006642 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006643 CmdArgs.push_back("-lgcc");
6644 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006645 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006646 CmdArgs.push_back("--as-needed");
6647 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006648 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006649 CmdArgs.push_back("--no-as-needed");
6650 }
6651
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006652 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006653 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006654 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006655 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006656
6657 // According to Android ABI, we have to link with libdl if we are
6658 // linking with non-static libgcc.
6659 //
6660 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6661 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6662 if (isAndroid && !StaticLibgcc)
6663 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006664}
6665
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006666static StringRef getLinuxDynamicLinker(const ArgList &Args,
6667 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006668 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6669 if (ToolChain.getTriple().isArch64Bit())
6670 return "/system/bin/linker64";
6671 else
6672 return "/system/bin/linker";
6673 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6674 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006675 return "/lib/ld-linux.so.2";
6676 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6677 return "/lib/ld-linux-aarch64.so.1";
Christian Pirkera74c7912014-03-14 12:15:45 +00006678 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6679 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006680 else if (ToolChain.getArch() == llvm::Triple::arm ||
6681 ToolChain.getArch() == llvm::Triple::thumb) {
6682 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6683 return "/lib/ld-linux-armhf.so.3";
6684 else
6685 return "/lib/ld-linux.so.3";
6686 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6687 ToolChain.getArch() == llvm::Triple::mipsel)
6688 return "/lib/ld.so.1";
6689 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6690 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006691 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006692 return "/lib32/ld.so.1";
6693 else
6694 return "/lib64/ld.so.1";
6695 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6696 return "/lib/ld.so.1";
6697 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidt778d3872013-07-26 01:36:11 +00006698 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006699 ToolChain.getArch() == llvm::Triple::systemz)
6700 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006701 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6702 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006703 else
6704 return "/lib64/ld-linux-x86-64.so.2";
6705}
6706
Renato Golinc4b49242014-02-13 10:01:16 +00006707static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6708 ArgStringList &CmdArgs, const ArgList &Args) {
6709 // Make use of compiler-rt if --rtlib option is used
6710 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6711
6712 switch(RLT) {
6713 case ToolChain::RLT_CompilerRT:
6714 addClangRTLinux(TC, Args, CmdArgs);
6715 break;
6716 case ToolChain::RLT_Libgcc:
6717 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6718 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006719 }
6720}
6721
Thomas Schwinge4e555262013-03-28 19:04:25 +00006722void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6723 const InputInfo &Output,
6724 const InputInfoList &Inputs,
6725 const ArgList &Args,
6726 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006727 const toolchains::Linux& ToolChain =
6728 static_cast<const toolchains::Linux&>(getToolChain());
6729 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006730 const bool isAndroid =
6731 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006732 const bool IsPIE =
6733 !Args.hasArg(options::OPT_shared) &&
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006734 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006735
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006736 ArgStringList CmdArgs;
6737
Rafael Espindolad1002f62010-11-15 18:28:16 +00006738 // Silence warning for "clang -g foo.o -o foo"
6739 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006740 // and "clang -emit-llvm foo.o -o foo"
6741 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00006742 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00006743 // handled somewhere else.
6744 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00006745
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006746 if (!D.SysRoot.empty())
6747 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006748
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006749 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00006750 CmdArgs.push_back("-pie");
6751
Rafael Espindola1c76c592010-11-07 22:57:16 +00006752 if (Args.hasArg(options::OPT_rdynamic))
6753 CmdArgs.push_back("-export-dynamic");
6754
Rafael Espindola34d77dc2010-11-11 19:34:42 +00006755 if (Args.hasArg(options::OPT_s))
6756 CmdArgs.push_back("-s");
6757
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006758 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6759 e = ToolChain.ExtraOpts.end();
6760 i != e; ++i)
6761 CmdArgs.push_back(i->c_str());
6762
6763 if (!Args.hasArg(options::OPT_static)) {
6764 CmdArgs.push_back("--eh-frame-hdr");
6765 }
6766
6767 CmdArgs.push_back("-m");
6768 if (ToolChain.getArch() == llvm::Triple::x86)
6769 CmdArgs.push_back("elf_i386");
Tim Northover9bb857a2013-01-31 12:13:10 +00006770 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6771 CmdArgs.push_back("aarch64linux");
Christian Pirkera74c7912014-03-14 12:15:45 +00006772 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6773 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00006774 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00006775 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006776 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00006777 else if (ToolChain.getArch() == llvm::Triple::ppc)
6778 CmdArgs.push_back("elf32ppclinux");
6779 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6780 CmdArgs.push_back("elf64ppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00006781 else if (ToolChain.getArch() == llvm::Triple::sparc)
6782 CmdArgs.push_back("elf32_sparc");
6783 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6784 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00006785 else if (ToolChain.getArch() == llvm::Triple::mips)
6786 CmdArgs.push_back("elf32btsmip");
6787 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6788 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006789 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006790 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006791 CmdArgs.push_back("elf32btsmipn32");
6792 else
6793 CmdArgs.push_back("elf64btsmip");
6794 }
6795 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006796 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006797 CmdArgs.push_back("elf32ltsmipn32");
6798 else
6799 CmdArgs.push_back("elf64ltsmip");
6800 }
Ulrich Weigand47445072013-05-06 16:26:41 +00006801 else if (ToolChain.getArch() == llvm::Triple::systemz)
6802 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006803 else
6804 CmdArgs.push_back("elf_x86_64");
6805
6806 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00006807 if (ToolChain.getArch() == llvm::Triple::arm ||
6808 ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006809 CmdArgs.push_back("-Bstatic");
6810 else
6811 CmdArgs.push_back("-static");
6812 } else if (Args.hasArg(options::OPT_shared)) {
6813 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00006814 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006815 CmdArgs.push_back("-Bsymbolic");
6816 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006817 }
6818
6819 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00006820 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006821 (!Args.hasArg(options::OPT_static) &&
6822 !Args.hasArg(options::OPT_shared))) {
6823 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006824 CmdArgs.push_back(Args.MakeArgString(
6825 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006826 }
6827
6828 CmdArgs.push_back("-o");
6829 CmdArgs.push_back(Output.getFilename());
6830
Rafael Espindola81937ec2010-12-01 01:52:43 +00006831 if (!Args.hasArg(options::OPT_nostdlib) &&
6832 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006833 if (!isAndroid) {
6834 const char *crt1 = NULL;
6835 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00006836 if (Args.hasArg(options::OPT_pg))
6837 crt1 = "gcrt1.o";
6838 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006839 crt1 = "Scrt1.o";
6840 else
6841 crt1 = "crt1.o";
6842 }
6843 if (crt1)
6844 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006845
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006846 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6847 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006848
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006849 const char *crtbegin;
6850 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006851 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006852 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006853 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006854 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006855 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006856 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006857 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006858 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00006859
6860 // Add crtfastmath.o if available and fast math is enabled.
6861 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006862 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006863
6864 Args.AddAllArgs(CmdArgs, options::OPT_L);
6865
6866 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6867
Roman Divackyee8188a2011-03-01 17:53:14 +00006868 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6869 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006870 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006871
Alp Tokerce365ca2013-12-02 12:43:03 +00006872 if (D.IsUsingLTO(Args))
6873 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00006874
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00006875 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6876 CmdArgs.push_back("--no-demangle");
6877
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006878 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6879
Alexey Samsonovce8ab102014-02-25 12:43:43 +00006880 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006881 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00006882 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006883
Hans Wennborg70850d82013-07-18 20:29:38 +00006884 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00006885 !Args.hasArg(options::OPT_nostdlib) &&
6886 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00006887 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6888 !Args.hasArg(options::OPT_static);
6889 if (OnlyLibstdcxxStatic)
6890 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006891 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00006892 if (OnlyLibstdcxxStatic)
6893 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006894 CmdArgs.push_back("-lm");
6895 }
6896
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006897 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00006898 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6899 if (Args.hasArg(options::OPT_static))
6900 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00006901
Alexey Bataev186b28a2014-03-06 05:43:53 +00006902 LibOpenMP UsedOpenMPLib = LibUnknown;
6903 if (Args.hasArg(options::OPT_fopenmp)) {
6904 UsedOpenMPLib = LibGOMP;
6905 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
6906 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
6907 .Case("libgomp", LibGOMP)
6908 .Case("libiomp5", LibIOMP5)
6909 .Default(LibUnknown);
6910 if (UsedOpenMPLib == LibUnknown)
6911 D.Diag(diag::err_drv_unsupported_option_argument)
6912 << A->getOption().getName() << A->getValue();
6913 }
6914 switch (UsedOpenMPLib) {
6915 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00006916 CmdArgs.push_back("-lgomp");
6917
Alp Tokerf6a24ce2013-12-05 16:25:25 +00006918 // FIXME: Exclude this for platforms with libgomp that don't require
6919 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00006920 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00006921 break;
6922 case LibIOMP5:
6923 CmdArgs.push_back("-liomp5");
6924 break;
6925 case LibUnknown:
6926 break;
Chandler Carruth01538002013-01-17 13:19:29 +00006927 }
Renato Golinc4b49242014-02-13 10:01:16 +00006928 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006929
Chandler Carruth94a32012012-05-14 18:31:18 +00006930 if (Args.hasArg(options::OPT_pthread) ||
Alexey Bataev648250a2014-03-07 07:43:52 +00006931 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown)
Chandler Carruth94a32012012-05-14 18:31:18 +00006932 CmdArgs.push_back("-lpthread");
6933
6934 CmdArgs.push_back("-lc");
6935
6936 if (Args.hasArg(options::OPT_static))
6937 CmdArgs.push_back("--end-group");
6938 else
Renato Golinc4b49242014-02-13 10:01:16 +00006939 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00006940 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00006941
Rafael Espindola81937ec2010-12-01 01:52:43 +00006942 if (!Args.hasArg(options::OPT_nostartfiles)) {
6943 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006944 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006945 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006946 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006947 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00006948 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006949 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006950
Rafael Espindola81937ec2010-12-01 01:52:43 +00006951 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006952 if (!isAndroid)
6953 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00006954 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006955 }
6956
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006957 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6958}
Rafael Espindola92b00932010-08-10 00:25:48 +00006959
Chris Lattner3e2ee142010-07-07 16:01:42 +00006960void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006961 const InputInfo &Output,
6962 const InputInfoList &Inputs,
6963 const ArgList &Args,
6964 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006965 ArgStringList CmdArgs;
6966
6967 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6968 options::OPT_Xassembler);
6969
6970 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006971 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006972
6973 for (InputInfoList::const_iterator
6974 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6975 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006976 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006977 }
6978
6979 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00006980 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006981 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006982}
6983
6984void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006985 const InputInfo &Output,
6986 const InputInfoList &Inputs,
6987 const ArgList &Args,
6988 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006989 const Driver &D = getToolChain().getDriver();
6990 ArgStringList CmdArgs;
6991
Daniel Dunbarb440f562010-08-02 02:38:21 +00006992 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006993 CmdArgs.push_back("-o");
6994 CmdArgs.push_back(Output.getFilename());
6995 } else {
6996 assert(Output.isNothing() && "Invalid output.");
6997 }
6998
6999 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007000 !Args.hasArg(options::OPT_nostartfiles)) {
7001 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7002 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7003 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7004 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7005 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007006
7007 Args.AddAllArgs(CmdArgs, options::OPT_L);
7008 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7009 Args.AddAllArgs(CmdArgs, options::OPT_e);
7010
Daniel Dunbar54423b22010-09-17 00:24:54 +00007011 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007012
Alexey Samsonov7811d192014-02-20 13:57:37 +00007013 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007014
Chris Lattner3e2ee142010-07-07 16:01:42 +00007015 if (!Args.hasArg(options::OPT_nostdlib) &&
7016 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007017 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007018 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007019 CmdArgs.push_back("-lm");
7020 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007021 }
7022
7023 if (!Args.hasArg(options::OPT_nostdlib) &&
7024 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007025 if (Args.hasArg(options::OPT_pthread))
7026 CmdArgs.push_back("-lpthread");
7027 CmdArgs.push_back("-lc");
7028 CmdArgs.push_back("-lCompilerRT-Generic");
7029 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7030 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007031 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007032 }
7033
Rafael Espindola236db462013-11-09 20:07:19 +00007034 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007035 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007036}
7037
Daniel Dunbarcc912342009-05-02 18:28:39 +00007038/// DragonFly Tools
7039
7040// For now, DragonFly Assemble does just about the same as for
7041// FreeBSD, but this may change soon.
7042void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007043 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007044 const InputInfoList &Inputs,
7045 const ArgList &Args,
7046 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007047 ArgStringList CmdArgs;
7048
7049 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7050 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007051 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007052 CmdArgs.push_back("--32");
7053
7054 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7055 options::OPT_Xassembler);
7056
7057 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007058 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007059
7060 for (InputInfoList::const_iterator
7061 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7062 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007063 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007064 }
7065
7066 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007067 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007068 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007069}
7070
7071void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007072 const InputInfo &Output,
7073 const InputInfoList &Inputs,
7074 const ArgList &Args,
7075 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007076 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007077 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007078 ArgStringList CmdArgs;
7079
John McCall65b8da02013-04-11 22:55:55 +00007080 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7081 UseGCC47 = false;
7082
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007083 if (!D.SysRoot.empty())
7084 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7085
John McCall65b8da02013-04-11 22:55:55 +00007086 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007087 if (Args.hasArg(options::OPT_static)) {
7088 CmdArgs.push_back("-Bstatic");
7089 } else {
John McCall65b8da02013-04-11 22:55:55 +00007090 if (Args.hasArg(options::OPT_rdynamic))
7091 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007092 if (Args.hasArg(options::OPT_shared))
7093 CmdArgs.push_back("-Bshareable");
7094 else {
7095 CmdArgs.push_back("-dynamic-linker");
7096 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7097 }
John McCall65b8da02013-04-11 22:55:55 +00007098 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007099 }
7100
7101 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7102 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007103 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007104 CmdArgs.push_back("-m");
7105 CmdArgs.push_back("elf_i386");
7106 }
7107
Daniel Dunbarb440f562010-08-02 02:38:21 +00007108 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007109 CmdArgs.push_back("-o");
7110 CmdArgs.push_back(Output.getFilename());
7111 } else {
7112 assert(Output.isNothing() && "Invalid output.");
7113 }
7114
7115 if (!Args.hasArg(options::OPT_nostdlib) &&
7116 !Args.hasArg(options::OPT_nostartfiles)) {
7117 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007118 if (Args.hasArg(options::OPT_pg))
7119 CmdArgs.push_back(Args.MakeArgString(
7120 getToolChain().GetFilePath("gcrt1.o")));
7121 else {
7122 if (Args.hasArg(options::OPT_pie))
7123 CmdArgs.push_back(Args.MakeArgString(
7124 getToolChain().GetFilePath("Scrt1.o")));
7125 else
7126 CmdArgs.push_back(Args.MakeArgString(
7127 getToolChain().GetFilePath("crt1.o")));
7128 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007129 }
John McCall65b8da02013-04-11 22:55:55 +00007130 CmdArgs.push_back(Args.MakeArgString(
7131 getToolChain().GetFilePath("crti.o")));
7132 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7133 CmdArgs.push_back(Args.MakeArgString(
7134 getToolChain().GetFilePath("crtbeginS.o")));
7135 else
7136 CmdArgs.push_back(Args.MakeArgString(
7137 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007138 }
7139
7140 Args.AddAllArgs(CmdArgs, options::OPT_L);
7141 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7142 Args.AddAllArgs(CmdArgs, options::OPT_e);
7143
Daniel Dunbar54423b22010-09-17 00:24:54 +00007144 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007145
7146 if (!Args.hasArg(options::OPT_nostdlib) &&
7147 !Args.hasArg(options::OPT_nodefaultlibs)) {
7148 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7149 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007150 if (UseGCC47)
7151 CmdArgs.push_back("-L/usr/lib/gcc47");
7152 else
7153 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007154
7155 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007156 if (UseGCC47) {
7157 CmdArgs.push_back("-rpath");
7158 CmdArgs.push_back("/usr/lib/gcc47");
7159 } else {
7160 CmdArgs.push_back("-rpath");
7161 CmdArgs.push_back("/usr/lib/gcc44");
7162 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007163 }
7164
Hans Wennborg70850d82013-07-18 20:29:38 +00007165 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007166 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007167 CmdArgs.push_back("-lm");
7168 }
7169
Daniel Dunbarcc912342009-05-02 18:28:39 +00007170 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007171 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007172
7173 if (!Args.hasArg(options::OPT_nolibc)) {
7174 CmdArgs.push_back("-lc");
7175 }
7176
John McCall65b8da02013-04-11 22:55:55 +00007177 if (UseGCC47) {
7178 if (Args.hasArg(options::OPT_static) ||
7179 Args.hasArg(options::OPT_static_libgcc)) {
7180 CmdArgs.push_back("-lgcc");
7181 CmdArgs.push_back("-lgcc_eh");
7182 } else {
7183 if (Args.hasArg(options::OPT_shared_libgcc)) {
7184 CmdArgs.push_back("-lgcc_pic");
7185 if (!Args.hasArg(options::OPT_shared))
7186 CmdArgs.push_back("-lgcc");
7187 } else {
7188 CmdArgs.push_back("-lgcc");
7189 CmdArgs.push_back("--as-needed");
7190 CmdArgs.push_back("-lgcc_pic");
7191 CmdArgs.push_back("--no-as-needed");
7192 }
7193 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007194 } else {
John McCall65b8da02013-04-11 22:55:55 +00007195 if (Args.hasArg(options::OPT_shared)) {
7196 CmdArgs.push_back("-lgcc_pic");
7197 } else {
7198 CmdArgs.push_back("-lgcc");
7199 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007200 }
7201 }
7202
7203 if (!Args.hasArg(options::OPT_nostdlib) &&
7204 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007205 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007206 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007207 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007208 else
7209 CmdArgs.push_back(Args.MakeArgString(
7210 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007211 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007212 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007213 }
7214
Alexey Samsonov7811d192014-02-20 13:57:37 +00007215 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007216
Daniel Dunbarcc912342009-05-02 18:28:39 +00007217 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00007218 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007219 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007220}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007221
7222void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7223 const InputInfo &Output,
7224 const InputInfoList &Inputs,
7225 const ArgList &Args,
7226 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007227 ArgStringList CmdArgs;
7228
7229 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007230 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7231 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007232 } else {
7233 assert(Output.isNothing() && "Invalid output.");
7234 }
7235
7236 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007237 !Args.hasArg(options::OPT_nostartfiles) &&
7238 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007239 CmdArgs.push_back("-defaultlib:libcmt");
7240 }
7241
7242 CmdArgs.push_back("-nologo");
7243
Hans Wennborgf1a74252013-09-10 20:18:04 +00007244 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7245
7246 if (DLL) {
7247 CmdArgs.push_back(Args.MakeArgString("-dll"));
7248
7249 SmallString<128> ImplibName(Output.getFilename());
7250 llvm::sys::path::replace_extension(ImplibName, "lib");
7251 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7252 ImplibName.str()));
7253 }
7254
Peter Collingbourne32701642013-11-01 18:16:25 +00007255 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007256 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007257 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborg65f17522013-08-27 18:10:21 +00007258 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007259 llvm::sys::path::append(LibSanitizer, "lib", "windows");
7260 if (DLL) {
Timur Iskhodzhanov3b6adcb62013-09-11 11:45:31 +00007261 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
Hans Wennborgf1a74252013-09-10 20:18:04 +00007262 } else {
7263 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
7264 }
7265 // FIXME: Handle 64-bit.
Hans Wennborg65f17522013-08-27 18:10:21 +00007266 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7267 }
7268
Michael J. Spencere2f49362012-06-18 16:56:04 +00007269 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007270 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007271
7272 // Add filenames immediately.
7273 for (InputInfoList::const_iterator
7274 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7275 if (it->isFilename())
7276 CmdArgs.push_back(it->getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007277 else
7278 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007279 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007280
7281 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007282 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007283 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7284}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007285
7286void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7287 const InputInfo &Output,
7288 const InputInfoList &Inputs,
7289 const ArgList &Args,
7290 const char *LinkingOutput) const {
7291 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7292}
7293
Hans Wennborg188382e2013-09-20 18:16:35 +00007294// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7295// If one cannot be found, return FallbackName.
7296// We do this special search to prevent clang-cl from falling back onto itself
7297// if it's available as cl.exe on the path.
7298static std::string FindFallback(const char *FallbackName,
7299 const char *ClangProgramPath) {
7300 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7301 if (!OptPath.hasValue())
7302 return FallbackName;
7303
7304#ifdef LLVM_ON_WIN32
7305 const StringRef PathSeparators = ";";
7306#else
7307 const StringRef PathSeparators = ":";
7308#endif
7309
7310 SmallVector<StringRef, 8> PathSegments;
7311 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7312
7313 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7314 const StringRef &PathSegment = PathSegments[i];
7315 if (PathSegment.empty())
7316 continue;
7317
7318 SmallString<128> FilePath(PathSegment);
7319 llvm::sys::path::append(FilePath, FallbackName);
7320 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7321 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7322 return FilePath.str();
7323 }
7324
7325 return FallbackName;
7326}
7327
Hans Wennborg87cfa712013-09-19 20:32:16 +00007328Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7329 const InputInfo &Output,
7330 const InputInfoList &Inputs,
7331 const ArgList &Args,
7332 const char *LinkingOutput) const {
7333 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007334 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007335 CmdArgs.push_back("/c"); // Compile only.
7336 CmdArgs.push_back("/W0"); // No warnings.
7337
7338 // The goal is to be able to invoke this tool correctly based on
7339 // any flag accepted by clang-cl.
7340
7341 // These are spelled the same way in clang and cl.exe,.
7342 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7343 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007344
7345 // Optimization level.
7346 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7347 if (A->getOption().getID() == options::OPT_O0) {
7348 CmdArgs.push_back("/Od");
7349 } else {
7350 StringRef OptLevel = A->getValue();
7351 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7352 A->render(Args, CmdArgs);
7353 else if (OptLevel == "3")
7354 CmdArgs.push_back("/Ox");
7355 }
7356 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007357
7358 // Flags for which clang-cl have an alias.
7359 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7360
7361 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7362 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7363 : "/GR-");
7364 if (Args.hasArg(options::OPT_fsyntax_only))
7365 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007366 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7367 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007368
Hans Wennborg260ff402013-09-27 17:54:18 +00007369 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7370 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7371 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7372
Hans Wennborg87cfa712013-09-19 20:32:16 +00007373 // Flags that can simply be passed through.
7374 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7375 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7376
7377 // The order of these flags is relevant, so pick the last one.
7378 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7379 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7380 A->render(Args, CmdArgs);
7381
7382
7383 // Input filename.
7384 assert(Inputs.size() == 1);
7385 const InputInfo &II = Inputs[0];
7386 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7387 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7388 if (II.isFilename())
7389 CmdArgs.push_back(II.getFilename());
7390 else
7391 II.getInputArg().renderAsInput(Args, CmdArgs);
7392
7393 // Output filename.
7394 assert(Output.getType() == types::TY_Object);
7395 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7396 Output.getFilename());
7397 CmdArgs.push_back(Fo);
7398
Hans Wennborg188382e2013-09-20 18:16:35 +00007399 const Driver &D = getToolChain().getDriver();
7400 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg87cfa712013-09-19 20:32:16 +00007401
Hans Wennborg188382e2013-09-20 18:16:35 +00007402 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007403}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007404
7405
7406/// XCore Tools
7407// We pass assemble and link construction to the xcc tool.
7408
7409void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7410 const InputInfo &Output,
7411 const InputInfoList &Inputs,
7412 const ArgList &Args,
7413 const char *LinkingOutput) const {
7414 ArgStringList CmdArgs;
7415
7416 CmdArgs.push_back("-o");
7417 CmdArgs.push_back(Output.getFilename());
7418
7419 CmdArgs.push_back("-c");
7420
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007421 if (Args.hasArg(options::OPT_v))
7422 CmdArgs.push_back("-v");
7423
7424 if (Args.hasArg(options::OPT_g_Group))
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007425 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007426
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007427 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7428 false))
7429 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007430
7431 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7432 options::OPT_Xassembler);
7433
7434 for (InputInfoList::const_iterator
7435 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7436 const InputInfo &II = *it;
7437 CmdArgs.push_back(II.getFilename());
7438 }
7439
7440 const char *Exec =
7441 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7442 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7443}
7444
7445void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7446 const InputInfo &Output,
7447 const InputInfoList &Inputs,
7448 const ArgList &Args,
7449 const char *LinkingOutput) const {
7450 ArgStringList CmdArgs;
7451
7452 if (Output.isFilename()) {
7453 CmdArgs.push_back("-o");
7454 CmdArgs.push_back(Output.getFilename());
7455 } else {
7456 assert(Output.isNothing() && "Invalid output.");
7457 }
7458
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007459 if (Args.hasArg(options::OPT_v))
7460 CmdArgs.push_back("-v");
7461
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007462 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7463 if (EH.ShouldUseExceptionTables)
7464 CmdArgs.push_back("-fexceptions");
7465
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007466 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7467
7468 const char *Exec =
7469 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7470 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7471}