blob: f808a18c7a783533f53a6df357930225b8673aa2 [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
Chad Rosierae229d52013-01-29 23:31:22 +00003140 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
3141 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3142 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3143 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3144
Eric Christopher459d2712013-02-19 06:16:53 +00003145 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003146 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003147 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003148 getToolChain().getArch() == llvm::Triple::ppc64 ||
3149 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003150 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003151 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003152
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003153 if (getToolChain().SupportsProfiling())
3154 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003155
3156 // -flax-vector-conversions is default.
3157 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3158 options::OPT_fno_lax_vector_conversions))
3159 CmdArgs.push_back("-fno-lax-vector-conversions");
3160
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003161 if (Args.getLastArg(options::OPT_fapple_kext))
3162 CmdArgs.push_back("-fapple-kext");
3163
David Blaikie690f21e2012-06-14 18:55:27 +00003164 if (Args.hasFlag(options::OPT_frewrite_includes,
3165 options::OPT_fno_rewrite_includes, false))
3166 CmdArgs.push_back("-frewrite-includes");
3167
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003168 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003169 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003170 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003171 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3172 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003173
3174 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3175 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003176 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003177 }
3178
Bob Wilson14adb362012-02-03 06:27:22 +00003179 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003180
Chandler Carruth6e501032011-03-27 00:04:55 +00003181 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3182 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3183 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3184 options::OPT_fno_wrapv)) {
3185 if (A->getOption().matches(options::OPT_fwrapv))
3186 CmdArgs.push_back("-fwrapv");
3187 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3188 options::OPT_fno_strict_overflow)) {
3189 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3190 CmdArgs.push_back("-fwrapv");
3191 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003192
3193 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3194 options::OPT_fno_reroll_loops))
3195 if (A->getOption().matches(options::OPT_freroll_loops))
3196 CmdArgs.push_back("-freroll-loops");
3197
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003198 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003199 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3200 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003201
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003202 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3203
Mahesha S6a682be42012-10-27 07:47:56 +00003204
Daniel Dunbar4930e332009-11-17 08:07:36 +00003205 // -stack-protector=0 is default.
3206 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003207 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3208 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003209 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003210 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003211 if (A->getOption().matches(options::OPT_fstack_protector))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003212 StackProtectorLevel = LangOptions::SSPOn;
3213 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3214 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003215 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003216 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003217 } else {
3218 StackProtectorLevel =
3219 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3220 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003221 if (StackProtectorLevel) {
3222 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003223 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003224 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003225
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003226 // --param ssp-buffer-size=
3227 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3228 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003229 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003230 if (Str.startswith("ssp-buffer-size=")) {
3231 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003232 CmdArgs.push_back("-stack-protector-buffer-size");
3233 // FIXME: Verify the argument is a valid integer.
3234 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003235 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003236 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003237 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003238 }
3239
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003240 // Translate -mstackrealign
3241 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3242 false)) {
3243 CmdArgs.push_back("-backend-option");
3244 CmdArgs.push_back("-force-align-stack");
3245 }
3246 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3247 false)) {
3248 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3249 }
3250
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003251 if (Args.hasArg(options::OPT_mstack_alignment)) {
3252 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3253 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003254 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003255 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003256 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003257 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3258 options::OPT_munaligned_access)) {
3259 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3260 CmdArgs.push_back("-backend-option");
3261 CmdArgs.push_back("-arm-strict-align");
3262 } else {
3263 CmdArgs.push_back("-backend-option");
3264 CmdArgs.push_back("-arm-no-strict-align");
3265 }
Renato Golina146a482013-08-24 14:44:41 +00003266 }
Chad Rosier60027022012-11-09 17:29:19 +00003267 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003268
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003269 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3270 options::OPT_mno_restrict_it)) {
3271 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3272 CmdArgs.push_back("-backend-option");
3273 CmdArgs.push_back("-arm-restrict-it");
3274 } else {
3275 CmdArgs.push_back("-backend-option");
3276 CmdArgs.push_back("-arm-no-restrict-it");
3277 }
3278 }
3279
Daniel Dunbard18049a2009-04-07 21:16:11 +00003280 // Forward -f options with positive and negative forms; we translate
3281 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003282 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3283 StringRef fname = A->getValue();
3284 if (!llvm::sys::fs::exists(fname))
3285 D.Diag(diag::err_drv_no_such_file) << fname;
3286 else
3287 A->render(Args, CmdArgs);
3288 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003289
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003290 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003291 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003292 CmdArgs.push_back("-fapple-kext");
3293 if (!Args.hasArg(options::OPT_fbuiltin))
3294 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003295 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003296 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003297 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003298 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003299 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003300
Nuno Lopes13c88c72009-12-16 16:59:22 +00003301 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3302 options::OPT_fno_assume_sane_operator_new))
3303 CmdArgs.push_back("-fno-assume-sane-operator-new");
3304
Daniel Dunbar4930e332009-11-17 08:07:36 +00003305 // -fblocks=0 is default.
3306 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003307 getToolChain().IsBlocksDefault()) ||
3308 (Args.hasArg(options::OPT_fgnu_runtime) &&
3309 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3310 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003311 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003312
3313 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3314 !getToolChain().hasBlocksRuntime())
3315 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003316 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003317
Douglas Gregor226173a2012-01-18 15:19:58 +00003318 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3319 // users must also pass -fcxx-modules. The latter flag will disappear once the
3320 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003321 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003322 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3323 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3324 options::OPT_fno_cxx_modules,
3325 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003326 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003327 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003328 HaveModules = true;
3329 }
3330 }
3331
Daniel Jasper07e6c402013-08-05 20:26:17 +00003332 // -fmodule-maps enables module map processing (off by default) for header
3333 // checking. It is implied by -fmodules.
3334 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3335 false)) {
3336 CmdArgs.push_back("-fmodule-maps");
3337 }
3338
Daniel Jasperac42b752013-10-21 06:34:34 +00003339 // -fmodules-decluse checks that modules used are declared so (off by
3340 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003341 if (Args.hasFlag(options::OPT_fmodules_decluse,
3342 options::OPT_fno_modules_decluse,
3343 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003344 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003345 }
3346
Daniel Jasperac42b752013-10-21 06:34:34 +00003347 // -fmodule-name specifies the module that is currently being built (or
3348 // used for header checking by -fmodule-maps).
3349 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3350 A->claim();
3351 A->render(Args, CmdArgs);
3352 }
3353
3354 // -fmodule-map-file can be used to specify a file containing module
3355 // definitions.
3356 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3357 A->claim();
3358 A->render(Args, CmdArgs);
3359 }
3360
Douglas Gregor35b04d62013-02-07 19:01:24 +00003361 // If a module path was provided, pass it along. Otherwise, use a temporary
3362 // directory.
3363 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3364 A->claim();
3365 if (HaveModules) {
3366 A->render(Args, CmdArgs);
3367 }
3368 } else if (HaveModules) {
3369 SmallString<128> DefaultModuleCache;
3370 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3371 DefaultModuleCache);
Douglas Gregor23c7d672013-03-21 21:48:48 +00003372 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3373 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00003374 const char Arg[] = "-fmodules-cache-path=";
3375 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3376 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003377 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3378 }
3379
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003380 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path)) {
3381 A->claim();
3382 if (HaveModules) {
3383 A->render(Args, CmdArgs);
3384 }
3385 }
3386
Douglas Gregor35b04d62013-02-07 19:01:24 +00003387 // Pass through all -fmodules-ignore-macro arguments.
3388 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003389 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3390 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003391
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003392 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3393
3394 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3395 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3396 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3397
3398 Args.AddLastArg(CmdArgs,
3399 options::OPT_fmodules_validate_once_per_build_session);
3400 }
3401
Ben Langmuirdcf73862014-03-12 00:06:17 +00003402 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3403
John McCalldfea9982010-04-09 19:12:06 +00003404 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003405 if (Args.hasFlag(options::OPT_fno_access_control,
3406 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003407 false))
John McCall3155f572010-04-09 19:03:51 +00003408 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003409
Anders Carlssond470fef2010-11-21 00:09:52 +00003410 // -felide-constructors is the default.
3411 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3412 options::OPT_felide_constructors,
3413 false))
3414 CmdArgs.push_back("-fno-elide-constructors");
3415
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003416 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003417 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003418 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003419 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003420
Richard Smith52be6192012-11-05 22:04:41 +00003421 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003422 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003423 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003424 Args.getLastArg(options::OPT_mkernel,
3425 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003426 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003427 D.Diag(diag::err_drv_argument_not_allowed_with)
3428 << "-fsanitize=vptr" << NoRttiArg;
3429 }
3430 }
3431
Tony Linthicum76329bf2011-12-12 21:14:55 +00003432 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003433 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003434 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003435 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003436 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003437 CmdArgs.push_back("-fshort-enums");
3438
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003439 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003440 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003441 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003442 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003443
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003444 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003445 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003446 options::OPT_fno_threadsafe_statics))
3447 CmdArgs.push_back("-fno-threadsafe-statics");
3448
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003449 // -fuse-cxa-atexit is default.
Rafael Espindolaa6775b62013-11-04 17:13:51 +00003450 if (!Args.hasFlag(
3451 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3452 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3453 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Robert Lytton6b1deb42013-11-12 10:09:22 +00003454 getToolChain().getArch() != llvm::Triple::hexagon &&
3455 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003456 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003457 CmdArgs.push_back("-fno-use-cxa-atexit");
3458
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003459 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003460 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003461 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3462 CmdArgs.push_back("-fms-extensions");
3463
Francois Pichet1b4f1632011-09-17 04:32:15 +00003464 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003465 if (Args.hasFlag(options::OPT_fms_compatibility,
3466 options::OPT_fno_ms_compatibility,
3467 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3468 Args.hasFlag(options::OPT_fms_extensions,
3469 options::OPT_fno_ms_extensions,
3470 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003471 CmdArgs.push_back("-fms-compatibility");
3472
Reid Klecknerc106fda2013-09-18 00:33:59 +00003473 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003474 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3475 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3476 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003477 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003478 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003479 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003480 else
3481 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3482 }
3483
3484
Eric Christopher5ecce122013-02-18 00:38:31 +00003485 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003486 if (Args.hasFlag(options::OPT_fborland_extensions,
3487 options::OPT_fno_borland_extensions, false))
3488 CmdArgs.push_back("-fborland-extensions");
3489
Francois Pichet02744872011-09-01 16:38:08 +00003490 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3491 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003492 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3493 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00003494 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003495 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003496
Chandler Carruthe03aa552010-04-17 20:17:31 +00003497 // -fgnu-keywords default varies depending on language; only pass if
3498 // specified.
3499 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003500 options::OPT_fno_gnu_keywords))
3501 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003502
Rafael Espindola922a6242011-06-02 17:30:53 +00003503 if (Args.hasFlag(options::OPT_fgnu89_inline,
3504 options::OPT_fno_gnu89_inline,
3505 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003506 CmdArgs.push_back("-fgnu89-inline");
3507
Chad Rosier9c76d242012-03-15 22:31:42 +00003508 if (Args.hasArg(options::OPT_fno_inline))
3509 CmdArgs.push_back("-fno-inline");
3510
Chad Rosier64d6be92012-03-06 21:17:19 +00003511 if (Args.hasArg(options::OPT_fno_inline_functions))
3512 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003513
John McCall5fb5df92012-06-20 06:18:46 +00003514 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003515
John McCall5fb5df92012-06-20 06:18:46 +00003516 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003517 // legacy is the default. Except for deployment taget of 10.5,
3518 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3519 // gets ignored silently.
3520 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003521 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3522 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003523 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003524 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003525 if (getToolChain().UseObjCMixedDispatch())
3526 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3527 else
3528 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3529 }
3530 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003531
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003532 // When ObjectiveC legacy runtime is in effect on MacOSX,
3533 // turn on the option to do Array/Dictionary subscripting
3534 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003535 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3536 getToolChain().getTriple().isMacOSX() &&
3537 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3538 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003539 objcRuntime.isNeXTFamily())
3540 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3541
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003542 // -fencode-extended-block-signature=1 is default.
3543 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3544 CmdArgs.push_back("-fencode-extended-block-signature");
3545 }
3546
John McCall24fc0de2011-07-06 00:26:06 +00003547 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3548 // NOTE: This logic is duplicated in ToolChains.cpp.
3549 bool ARC = isObjCAutoRefCount(Args);
3550 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003551 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003552
John McCall24fc0de2011-07-06 00:26:06 +00003553 CmdArgs.push_back("-fobjc-arc");
3554
Chandler Carruth491db322011-11-04 07:34:47 +00003555 // FIXME: It seems like this entire block, and several around it should be
3556 // wrapped in isObjC, but for now we just use it here as this is where it
3557 // was being used previously.
3558 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3559 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3560 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3561 else
3562 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3563 }
3564
John McCall24fc0de2011-07-06 00:26:06 +00003565 // Allow the user to enable full exceptions code emission.
3566 // We define off for Objective-CC, on for Objective-C++.
3567 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3568 options::OPT_fno_objc_arc_exceptions,
3569 /*default*/ types::isCXX(InputType)))
3570 CmdArgs.push_back("-fobjc-arc-exceptions");
3571 }
3572
3573 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3574 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003575 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003576 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003577
John McCall24fc0de2011-07-06 00:26:06 +00003578 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3579 // takes precedence.
3580 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3581 if (!GCArg)
3582 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3583 if (GCArg) {
3584 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003585 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003586 << GCArg->getAsString(Args);
3587 } else if (getToolChain().SupportsObjCGC()) {
3588 GCArg->render(Args, CmdArgs);
3589 } else {
3590 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003591 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003592 << GCArg->getAsString(Args);
3593 }
3594 }
3595
John McCallb5f652e2011-06-22 00:53:57 +00003596 // Add exception args.
3597 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003598 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003599
3600 if (getToolChain().UseSjLjExceptions())
3601 CmdArgs.push_back("-fsjlj-exceptions");
3602
3603 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003604 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3605 options::OPT_fno_assume_sane_operator_new))
3606 CmdArgs.push_back("-fno-assume-sane-operator-new");
3607
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003608 // -fconstant-cfstrings is default, and may be subject to argument translation
3609 // on Darwin.
3610 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3611 options::OPT_fno_constant_cfstrings) ||
3612 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3613 options::OPT_mno_constant_cfstrings))
3614 CmdArgs.push_back("-fno-constant-cfstrings");
3615
John Thompsoned4e2952009-11-05 20:14:16 +00003616 // -fshort-wchar default varies depending on platform; only
3617 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003618 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3619 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003620 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003621
Hans Wennborg28c96312013-07-31 23:39:13 +00003622 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003623 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003624 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003625 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003626 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003627
Daniel Dunbar096ed292011-10-05 21:04:55 +00003628 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3629 // -fno-pack-struct doesn't apply to -fpack-struct=.
3630 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003631 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003632 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003633 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003634 } else if (Args.hasFlag(options::OPT_fpack_struct,
3635 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003636 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003637 }
3638
Robert Lytton0e076492013-08-13 09:43:10 +00003639 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003640 if (!Args.hasArg(options::OPT_fcommon))
3641 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003642 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003643 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003644
Daniel Dunbard18049a2009-04-07 21:16:11 +00003645 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003646 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003647 CmdArgs.push_back("-fno-common");
3648
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003649 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003650 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003651 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003652 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003653 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003654 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3655
Daniel Dunbar6358d682010-10-15 22:30:42 +00003656 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3657 if (!Args.hasFlag(options::OPT_ffor_scope,
3658 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003659 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003660 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3661
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003662 // -fcaret-diagnostics is default.
3663 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3664 options::OPT_fno_caret_diagnostics, true))
3665 CmdArgs.push_back("-fno-caret-diagnostics");
3666
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003667 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003668 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003669 options::OPT_fno_diagnostics_fixit_info))
3670 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003671
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003672 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003673 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003674 options::OPT_fno_diagnostics_show_option))
3675 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003676
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003677 if (const Arg *A =
3678 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3679 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003680 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003681 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003682
Douglas Gregor643c9222011-05-21 17:07:29 +00003683 if (const Arg *A =
3684 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3685 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003686 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003687 }
3688
Chandler Carruthb6766f02011-03-27 01:50:55 +00003689 if (Arg *A = Args.getLastArg(
3690 options::OPT_fdiagnostics_show_note_include_stack,
3691 options::OPT_fno_diagnostics_show_note_include_stack)) {
3692 if (A->getOption().matches(
3693 options::OPT_fdiagnostics_show_note_include_stack))
3694 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3695 else
3696 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3697 }
3698
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003699 // Color diagnostics are the default, unless the terminal doesn't support
3700 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003701 // Support both clang's -f[no-]color-diagnostics and gcc's
3702 // -f[no-]diagnostics-colors[=never|always|auto].
3703 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3704 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3705 it != ie; ++it) {
3706 const Option &O = (*it)->getOption();
3707 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3708 !O.matches(options::OPT_fdiagnostics_color) &&
3709 !O.matches(options::OPT_fno_color_diagnostics) &&
3710 !O.matches(options::OPT_fno_diagnostics_color) &&
3711 !O.matches(options::OPT_fdiagnostics_color_EQ))
3712 continue;
3713
3714 (*it)->claim();
3715 if (O.matches(options::OPT_fcolor_diagnostics) ||
3716 O.matches(options::OPT_fdiagnostics_color)) {
3717 ShowColors = Colors_On;
3718 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3719 O.matches(options::OPT_fno_diagnostics_color)) {
3720 ShowColors = Colors_Off;
3721 } else {
3722 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3723 StringRef value((*it)->getValue());
3724 if (value == "always")
3725 ShowColors = Colors_On;
3726 else if (value == "never")
3727 ShowColors = Colors_Off;
3728 else if (value == "auto")
3729 ShowColors = Colors_Auto;
3730 else
3731 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3732 << ("-fdiagnostics-color=" + value).str();
3733 }
3734 }
3735 if (ShowColors == Colors_On ||
3736 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003737 CmdArgs.push_back("-fcolor-diagnostics");
3738
Nico Rieck7857d462013-09-11 00:38:02 +00003739 if (Args.hasArg(options::OPT_fansi_escape_codes))
3740 CmdArgs.push_back("-fansi-escape-codes");
3741
Daniel Dunbardb097022009-06-08 21:13:54 +00003742 if (!Args.hasFlag(options::OPT_fshow_source_location,
3743 options::OPT_fno_show_source_location))
3744 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003745
Douglas Gregor643c9222011-05-21 17:07:29 +00003746 if (!Args.hasFlag(options::OPT_fshow_column,
3747 options::OPT_fno_show_column,
3748 true))
3749 CmdArgs.push_back("-fno-show-column");
3750
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003751 if (!Args.hasFlag(options::OPT_fspell_checking,
3752 options::OPT_fno_spell_checking))
3753 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003754
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003755
Chad Rosierc8e56e82012-12-05 21:08:21 +00003756 // -fno-asm-blocks is default.
3757 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3758 false))
3759 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003760
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003761 // Enable vectorization per default according to the optimization level
3762 // selected. For optimization levels that want vectorization we use the alias
3763 // option to simplify the hasFlag logic.
3764 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3765 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003766 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003767 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003768 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003769 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003770
Rafael Espindolaf818ef42013-08-01 23:56:42 +00003771 // -fslp-vectorize is default.
3772 if (Args.hasFlag(options::OPT_fslp_vectorize,
3773 options::OPT_fno_slp_vectorize, true))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00003774 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00003775
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003776 // -fno-slp-vectorize-aggressive is default.
3777 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003778 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003779 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003780
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00003781 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3782 A->render(Args, CmdArgs);
3783
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003784 // -fdollars-in-identifiers default varies depending on platform and
3785 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003786 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003787 options::OPT_fno_dollars_in_identifiers)) {
3788 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003789 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003790 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003791 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003792 }
3793
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003794 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3795 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003796 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003797 options::OPT_fno_unit_at_a_time)) {
3798 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003799 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003800 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003801
Eli Friedman055c9702011-11-02 01:53:16 +00003802 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3803 options::OPT_fno_apple_pragma_pack, false))
3804 CmdArgs.push_back("-fapple-pragma-pack");
3805
Eli Benderskyc95cfe82013-07-24 18:20:14 +00003806 // le32-specific flags:
3807 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3808 // by default.
3809 if (getToolChain().getArch() == llvm::Triple::le32) {
3810 CmdArgs.push_back("-fno-math-builtin");
3811 }
3812
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003813 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003814 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003815 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003816#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00003817 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003818 (getToolChain().getArch() == llvm::Triple::arm ||
3819 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003820 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3821 CmdArgs.push_back("-fno-builtin-strcat");
3822 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3823 CmdArgs.push_back("-fno-builtin-strcpy");
3824 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003825#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003826
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003827 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00003828 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003829 options::OPT_traditional_cpp)) {
3830 if (isa<PreprocessJobAction>(JA))
3831 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003832 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003833 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003834 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003835
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003836 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00003837 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003838
3839 // Handle serialized diagnostics.
3840 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3841 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003842 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003843 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003844
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003845 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3846 CmdArgs.push_back("-fretain-comments-from-system-headers");
3847
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003848 // Forward -fcomment-block-commands to -cc1.
3849 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00003850 // Forward -fparse-all-comments to -cc1.
3851 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003852
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003853 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3854 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003855 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003856 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3857 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003858 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003859
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003860 // We translate this by hand to the -cc1 argument, since nightly test uses
3861 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003862 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003863 CmdArgs.push_back("-disable-llvm-optzns");
3864 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003865 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003866 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003867
Daniel Dunbard67a3222009-03-30 06:36:42 +00003868 if (Output.getType() == types::TY_Dependencies) {
3869 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003870 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003871 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003872 CmdArgs.push_back(Output.getFilename());
3873 } else {
3874 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003875 }
3876
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003877 for (InputInfoList::const_iterator
3878 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3879 const InputInfo &II = *it;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00003880
3881 addDashXForInput(Args, II, CmdArgs);
3882
Daniel Dunbarb440f562010-08-02 02:38:21 +00003883 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003884 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003885 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003886 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003887 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003888
Chris Lattnere9d7d782009-11-03 19:50:27 +00003889 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3890
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003891 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003892
3893 // Optionally embed the -cc1 level arguments into the debug info, for build
3894 // analysis.
3895 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003896 ArgStringList OriginalArgs;
3897 for (ArgList::const_iterator it = Args.begin(),
3898 ie = Args.end(); it != ie; ++it)
3899 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003900
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003901 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003902 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003903 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003904 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003905 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003906 }
3907 CmdArgs.push_back("-dwarf-debug-flags");
3908 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3909 }
3910
Eric Christopherd3804002013-02-22 20:12:52 +00003911 // Add the split debug info name to the command lines here so we
3912 // can propagate it to the backend.
3913 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003914 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00003915 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00003916 const char *SplitDwarfOut;
3917 if (SplitDwarf) {
3918 CmdArgs.push_back("-split-dwarf-file");
3919 SplitDwarfOut = SplitDebugName(Args, Inputs);
3920 CmdArgs.push_back(SplitDwarfOut);
3921 }
3922
3923 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00003924 if (Args.hasArg(options::OPT__SLASH_fallback) &&
3925 Output.getType() == types::TY_Object) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00003926 tools::visualstudio::Compile CL(getToolChain());
3927 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3928 LinkingOutput);
3929 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3930 } else {
3931 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3932 }
3933
Daniel Dunbar17731772009-03-23 19:03:36 +00003934
Eric Christopherf1545832013-02-22 23:50:16 +00003935 // Handle the debug info splitting at object creation time if we're
3936 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00003937 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00003938 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00003939 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00003940
Roman Divacky178e01602011-02-10 16:52:03 +00003941 if (Arg *A = Args.getLastArg(options::OPT_pg))
3942 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003943 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003944 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003945
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003946 // Claim some arguments which clang supports automatically.
3947
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003948 // -fpch-preprocess is used with gcc to add a special marker in the output to
3949 // include the PCH file. Clang's PTH solution is completely transparent, so we
3950 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003951 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003952
Daniel Dunbar17731772009-03-23 19:03:36 +00003953 // Claim some arguments which clang doesn't support, but we don't
3954 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003955 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3956 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003957
Rafael Espindolab0092d72013-09-04 19:37:35 +00003958 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00003959 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003960}
3961
John McCall5fb5df92012-06-20 06:18:46 +00003962/// Add options related to the Objective-C runtime/ABI.
3963///
3964/// Returns true if the runtime is non-fragile.
3965ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3966 ArgStringList &cmdArgs,
3967 RewriteKind rewriteKind) const {
3968 // Look for the controlling runtime option.
3969 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3970 options::OPT_fgnu_runtime,
3971 options::OPT_fobjc_runtime_EQ);
3972
3973 // Just forward -fobjc-runtime= to the frontend. This supercedes
3974 // options about fragility.
3975 if (runtimeArg &&
3976 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3977 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003978 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003979 if (runtime.tryParse(value)) {
3980 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3981 << value;
3982 }
3983
3984 runtimeArg->render(args, cmdArgs);
3985 return runtime;
3986 }
3987
3988 // Otherwise, we'll need the ABI "version". Version numbers are
3989 // slightly confusing for historical reasons:
3990 // 1 - Traditional "fragile" ABI
3991 // 2 - Non-fragile ABI, version 1
3992 // 3 - Non-fragile ABI, version 2
3993 unsigned objcABIVersion = 1;
3994 // If -fobjc-abi-version= is present, use that to set the version.
3995 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003996 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003997 if (value == "1")
3998 objcABIVersion = 1;
3999 else if (value == "2")
4000 objcABIVersion = 2;
4001 else if (value == "3")
4002 objcABIVersion = 3;
4003 else
4004 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4005 << value;
4006 } else {
4007 // Otherwise, determine if we are using the non-fragile ABI.
4008 bool nonFragileABIIsDefault =
4009 (rewriteKind == RK_NonFragile ||
4010 (rewriteKind == RK_None &&
4011 getToolChain().IsObjCNonFragileABIDefault()));
4012 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4013 options::OPT_fno_objc_nonfragile_abi,
4014 nonFragileABIIsDefault)) {
4015 // Determine the non-fragile ABI version to use.
4016#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4017 unsigned nonFragileABIVersion = 1;
4018#else
4019 unsigned nonFragileABIVersion = 2;
4020#endif
4021
4022 if (Arg *abiArg = args.getLastArg(
4023 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004024 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004025 if (value == "1")
4026 nonFragileABIVersion = 1;
4027 else if (value == "2")
4028 nonFragileABIVersion = 2;
4029 else
4030 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4031 << value;
4032 }
4033
4034 objcABIVersion = 1 + nonFragileABIVersion;
4035 } else {
4036 objcABIVersion = 1;
4037 }
4038 }
4039
4040 // We don't actually care about the ABI version other than whether
4041 // it's non-fragile.
4042 bool isNonFragile = objcABIVersion != 1;
4043
4044 // If we have no runtime argument, ask the toolchain for its default runtime.
4045 // However, the rewriter only really supports the Mac runtime, so assume that.
4046 ObjCRuntime runtime;
4047 if (!runtimeArg) {
4048 switch (rewriteKind) {
4049 case RK_None:
4050 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4051 break;
4052 case RK_Fragile:
4053 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4054 break;
4055 case RK_NonFragile:
4056 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4057 break;
4058 }
4059
4060 // -fnext-runtime
4061 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4062 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004063 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004064 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4065
4066 // Otherwise, build for a generic macosx port.
4067 } else {
4068 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4069 }
4070
4071 // -fgnu-runtime
4072 } else {
4073 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004074 // Legacy behaviour is to target the gnustep runtime if we are i
4075 // non-fragile mode or the GCC runtime in fragile mode.
4076 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004077 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004078 else
4079 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004080 }
4081
4082 cmdArgs.push_back(args.MakeArgString(
4083 "-fobjc-runtime=" + runtime.getAsString()));
4084 return runtime;
4085}
4086
Hans Wennborg75958c42013-08-08 00:17:41 +00004087void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4088 unsigned RTOptionID = options::OPT__SLASH_MT;
4089
Hans Wennborgf1a74252013-09-10 20:18:04 +00004090 if (Args.hasArg(options::OPT__SLASH_LDd))
4091 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4092 // but defining _DEBUG is sticky.
4093 RTOptionID = options::OPT__SLASH_MTd;
4094
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004095 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004096 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004097
Hans Wennborg75958c42013-08-08 00:17:41 +00004098 switch(RTOptionID) {
4099 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004100 if (Args.hasArg(options::OPT__SLASH_LDd))
4101 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004102 CmdArgs.push_back("-D_MT");
4103 CmdArgs.push_back("-D_DLL");
4104 CmdArgs.push_back("--dependent-lib=msvcrt");
4105 break;
4106 case options::OPT__SLASH_MDd:
4107 CmdArgs.push_back("-D_DEBUG");
4108 CmdArgs.push_back("-D_MT");
4109 CmdArgs.push_back("-D_DLL");
4110 CmdArgs.push_back("--dependent-lib=msvcrtd");
4111 break;
4112 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004113 if (Args.hasArg(options::OPT__SLASH_LDd))
4114 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004115 CmdArgs.push_back("-D_MT");
4116 CmdArgs.push_back("--dependent-lib=libcmt");
4117 break;
4118 case options::OPT__SLASH_MTd:
4119 CmdArgs.push_back("-D_DEBUG");
4120 CmdArgs.push_back("-D_MT");
4121 CmdArgs.push_back("--dependent-lib=libcmtd");
4122 break;
4123 default:
4124 llvm_unreachable("Unexpected option ID.");
4125 }
4126
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004127 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4128 // users want. The /Za flag to cl.exe turns this off, but it's not
4129 // implemented in clang.
4130 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004131
Hans Wennborg0fd62072013-08-09 00:32:23 +00004132 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4133 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004134
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004135 // RTTI is currently not supported, so disable it by default.
4136 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4137 CmdArgs.push_back("-fno-rtti");
4138
David Majnemer86c318f2014-02-11 21:05:00 +00004139 const Driver &D = getToolChain().getDriver();
4140 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4141 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4142 if (MostGeneralArg && BestCaseArg)
4143 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4144 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4145
4146 if (MostGeneralArg) {
4147 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4148 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4149 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4150
4151 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4152 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4153 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4154 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4155 << FirstConflict->getAsString(Args)
4156 << SecondConflict->getAsString(Args);
4157
4158 if (SingleArg)
4159 CmdArgs.push_back("-fms-memptr-rep=single");
4160 else if (MultipleArg)
4161 CmdArgs.push_back("-fms-memptr-rep=multiple");
4162 else
4163 CmdArgs.push_back("-fms-memptr-rep=virtual");
4164 }
4165
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004166 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4167 A->render(Args, CmdArgs);
4168
Hans Wennborg81f74482013-09-10 01:07:07 +00004169 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4170 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004171 if (Args.hasArg(options::OPT__SLASH_fallback))
4172 CmdArgs.push_back("msvc-fallback");
4173 else
4174 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004175 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004176}
4177
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004178void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004179 const InputInfo &Output,
4180 const InputInfoList &Inputs,
4181 const ArgList &Args,
4182 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004183 ArgStringList CmdArgs;
4184
4185 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4186 const InputInfo &Input = Inputs[0];
4187
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004188 // Don't warn about "clang -w -c foo.s"
4189 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004190 // and "clang -emit-llvm -c foo.s"
4191 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004192
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004193 // Invoke ourselves in -cc1as mode.
4194 //
4195 // FIXME: Implement custom jobs for internal actions.
4196 CmdArgs.push_back("-cc1as");
4197
4198 // Add the "effective" target triple.
4199 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004200 std::string TripleStr =
4201 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004202 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4203
4204 // Set the output mode, we currently only expect to be used as a real
4205 // assembler.
4206 CmdArgs.push_back("-filetype");
4207 CmdArgs.push_back("obj");
4208
Eric Christopher45f2e712012-12-18 00:31:10 +00004209 // Set the main file name, so that debug info works even with
4210 // -save-temps or preprocessed assembly.
4211 CmdArgs.push_back("-main-file-name");
4212 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4213
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004214 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004215 const llvm::Triple &Triple = getToolChain().getTriple();
4216 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004217 if (!CPU.empty()) {
4218 CmdArgs.push_back("-target-cpu");
4219 CmdArgs.push_back(Args.MakeArgString(CPU));
4220 }
4221
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004222 // Add the target features
4223 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004224 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004225
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004226 // Ignore explicit -force_cpusubtype_ALL option.
4227 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004228
Eric Christopherfc3ee562012-01-10 00:38:01 +00004229 // Determine the original source input.
4230 const Action *SourceAction = &JA;
4231 while (SourceAction->getKind() != Action::InputClass) {
4232 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4233 SourceAction = SourceAction->getInputs()[0];
4234 }
4235
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004236 // Forward -g and handle debug info related flags, assuming we are dealing
4237 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004238 if (SourceAction->getType() == types::TY_Asm ||
4239 SourceAction->getType() == types::TY_PP_Asm) {
4240 Args.ClaimAllArgs(options::OPT_g_Group);
4241 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4242 if (!A->getOption().matches(options::OPT_g0))
4243 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004244
4245 // Add the -fdebug-compilation-dir flag if needed.
4246 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004247
4248 // Set the AT_producer to the clang version when using the integrated
4249 // assembler on assembly source files.
4250 CmdArgs.push_back("-dwarf-debug-producer");
4251 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004252 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004253
4254 // Optionally embed the -cc1as level arguments into the debug info, for build
4255 // analysis.
4256 if (getToolChain().UseDwarfDebugFlags()) {
4257 ArgStringList OriginalArgs;
4258 for (ArgList::const_iterator it = Args.begin(),
4259 ie = Args.end(); it != ie; ++it)
4260 (*it)->render(Args, OriginalArgs);
4261
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004262 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004263 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4264 Flags += Exec;
4265 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4266 Flags += " ";
4267 Flags += OriginalArgs[i];
4268 }
4269 CmdArgs.push_back("-dwarf-debug-flags");
4270 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4271 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004272
4273 // FIXME: Add -static support, once we have it.
4274
David Blaikie372d9502014-01-17 03:17:40 +00004275 // Consume all the warning flags. Usually this would be handled more
4276 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4277 // doesn't handle that so rather than warning about unused flags that are
4278 // actually used, we'll lie by omission instead.
4279 // FIXME: Stop lying and consume only the appropriate driver flags
4280 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4281 ie = Args.filtered_end();
4282 it != ie; ++it)
4283 (*it)->claim();
4284
David Blaikie9260ed62013-07-25 21:19:01 +00004285 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4286 getToolChain().getDriver());
4287
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004288 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004289
4290 assert(Output.isFilename() && "Unexpected lipo output.");
4291 CmdArgs.push_back("-o");
4292 CmdArgs.push_back(Output.getFilename());
4293
Daniel Dunbarb440f562010-08-02 02:38:21 +00004294 assert(Input.isFilename() && "Invalid input.");
4295 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004296
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004297 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004298 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004299
4300 // Handle the debug info splitting at object creation time if we're
4301 // creating an object.
4302 // TODO: Currently only works on linux with newer objcopy.
4303 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004304 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004305 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4306 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004307}
4308
Daniel Dunbara3246a02009-03-18 08:07:30 +00004309void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004310 const InputInfo &Output,
4311 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004312 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004313 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004314 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004315 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004316
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004317 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004318 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004319 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004320 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004321 // Don't forward any -g arguments to assembly steps.
4322 if (isa<AssembleJobAction>(JA) &&
4323 A->getOption().matches(options::OPT_g_Group))
4324 continue;
4325
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004326 // Don't forward any -W arguments to assembly and link steps.
4327 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4328 A->getOption().matches(options::OPT_W_Group))
4329 continue;
4330
Daniel Dunbar2da02722009-03-19 07:55:12 +00004331 // It is unfortunate that we have to claim here, as this means
4332 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004333 // platforms using a generic gcc, even if we are just using gcc
4334 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004335 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004336 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004337 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004338 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004339
Daniel Dunbar4e295052010-01-25 22:35:08 +00004340 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004341
4342 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004343 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004344 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004345 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004346
4347 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004348 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004349 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004350 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004351 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004352 else if (Arch == llvm::Triple::ppc64le)
4353 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004354 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004355 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004356 }
4357
Daniel Dunbar5716d872009-05-02 21:41:52 +00004358 // Try to force gcc to match the tool chain we want, if we recognize
4359 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004360 //
4361 // FIXME: The triple class should directly provide the information we want
4362 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004363 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004364 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004365 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4366 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004367 CmdArgs.push_back("-m64");
4368
Daniel Dunbarb440f562010-08-02 02:38:21 +00004369 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004370 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004371 CmdArgs.push_back(Output.getFilename());
4372 } else {
4373 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004374 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004375 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004376
Tony Linthicum76329bf2011-12-12 21:14:55 +00004377 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4378 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004379
4380 // Only pass -x if gcc will understand it; otherwise hope gcc
4381 // understands the suffix correctly. The main use case this would go
4382 // wrong in is for linker inputs if they happened to have an odd
4383 // suffix; really the only way to get this to happen is a command
4384 // like '-x foobar a.c' which will treat a.c like a linker input.
4385 //
4386 // FIXME: For the linker case specifically, can we safely convert
4387 // inputs into '-Wl,' options?
4388 for (InputInfoList::const_iterator
4389 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4390 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004391
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004392 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004393 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4394 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004395 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004396 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004397 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004398 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004399 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004400 else if (II.getType() == types::TY_ModuleFile)
4401 D.Diag(diag::err_drv_no_module_support)
4402 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004403
Daniel Dunbara3246a02009-03-18 08:07:30 +00004404 if (types::canTypeBeUserSpecified(II.getType())) {
4405 CmdArgs.push_back("-x");
4406 CmdArgs.push_back(types::getTypeName(II.getType()));
4407 }
4408
Daniel Dunbarb440f562010-08-02 02:38:21 +00004409 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004410 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004411 else {
4412 const Arg &A = II.getInputArg();
4413
4414 // Reverse translate some rewritten options.
4415 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4416 CmdArgs.push_back("-lstdc++");
4417 continue;
4418 }
4419
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004420 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004421 A.render(Args, CmdArgs);
4422 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004423 }
4424
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004425 const std::string customGCCName = D.getCCCGenericGCCName();
4426 const char *GCCName;
4427 if (!customGCCName.empty())
4428 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004429 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004430 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004431 } else
4432 GCCName = "gcc";
4433
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004434 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004435 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004436 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004437}
4438
Daniel Dunbar4e295052010-01-25 22:35:08 +00004439void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4440 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004441 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004442}
4443
Daniel Dunbar4e295052010-01-25 22:35:08 +00004444void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4445 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004446 const Driver &D = getToolChain().getDriver();
4447
Daniel Dunbar4e295052010-01-25 22:35:08 +00004448 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004449 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4450 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004451 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004452 else {
4453 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004454 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004455 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004456
Daniel Dunbar4e295052010-01-25 22:35:08 +00004457 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004458 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004459}
4460
Daniel Dunbar4e295052010-01-25 22:35:08 +00004461void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4462 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004463 // The types are (hopefully) good enough.
4464}
4465
Tony Linthicum76329bf2011-12-12 21:14:55 +00004466// Hexagon tools start.
4467void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4468 ArgStringList &CmdArgs) const {
4469
4470}
4471void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4472 const InputInfo &Output,
4473 const InputInfoList &Inputs,
4474 const ArgList &Args,
4475 const char *LinkingOutput) const {
4476
4477 const Driver &D = getToolChain().getDriver();
4478 ArgStringList CmdArgs;
4479
4480 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004481 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004482 CmdArgs.push_back(Args.MakeArgString(MarchString));
4483
4484 RenderExtraToolArgs(JA, CmdArgs);
4485
4486 if (Output.isFilename()) {
4487 CmdArgs.push_back("-o");
4488 CmdArgs.push_back(Output.getFilename());
4489 } else {
4490 assert(Output.isNothing() && "Unexpected output");
4491 CmdArgs.push_back("-fsyntax-only");
4492 }
4493
Matthew Curtise8f80a12012-12-06 17:49:03 +00004494 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4495 if (!SmallDataThreshold.empty())
4496 CmdArgs.push_back(
4497 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004498
Matthew Curtise5df3812012-12-07 17:23:04 +00004499 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4500 options::OPT_Xassembler);
4501
Tony Linthicum76329bf2011-12-12 21:14:55 +00004502 // Only pass -x if gcc will understand it; otherwise hope gcc
4503 // understands the suffix correctly. The main use case this would go
4504 // wrong in is for linker inputs if they happened to have an odd
4505 // suffix; really the only way to get this to happen is a command
4506 // like '-x foobar a.c' which will treat a.c like a linker input.
4507 //
4508 // FIXME: For the linker case specifically, can we safely convert
4509 // inputs into '-Wl,' options?
4510 for (InputInfoList::const_iterator
4511 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4512 const InputInfo &II = *it;
4513
4514 // Don't try to pass LLVM or AST inputs to a generic gcc.
4515 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4516 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4517 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4518 << getToolChain().getTripleString();
4519 else if (II.getType() == types::TY_AST)
4520 D.Diag(clang::diag::err_drv_no_ast_support)
4521 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004522 else if (II.getType() == types::TY_ModuleFile)
4523 D.Diag(diag::err_drv_no_module_support)
4524 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004525
4526 if (II.isFilename())
4527 CmdArgs.push_back(II.getFilename());
4528 else
4529 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4530 II.getInputArg().render(Args, CmdArgs);
4531 }
4532
4533 const char *GCCName = "hexagon-as";
4534 const char *Exec =
4535 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4536 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4537
4538}
4539void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4540 ArgStringList &CmdArgs) const {
4541 // The types are (hopefully) good enough.
4542}
4543
4544void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4545 const InputInfo &Output,
4546 const InputInfoList &Inputs,
4547 const ArgList &Args,
4548 const char *LinkingOutput) const {
4549
Matthew Curtise689b052012-12-06 15:46:07 +00004550 const toolchains::Hexagon_TC& ToolChain =
4551 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4552 const Driver &D = ToolChain.getDriver();
4553
Tony Linthicum76329bf2011-12-12 21:14:55 +00004554 ArgStringList CmdArgs;
4555
Matthew Curtise689b052012-12-06 15:46:07 +00004556 //----------------------------------------------------------------------------
4557 //
4558 //----------------------------------------------------------------------------
4559 bool hasStaticArg = Args.hasArg(options::OPT_static);
4560 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004561 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004562 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4563 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4564 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4565 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004566
Matthew Curtise689b052012-12-06 15:46:07 +00004567 //----------------------------------------------------------------------------
4568 // Silence warnings for various options
4569 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004570
Matthew Curtise689b052012-12-06 15:46:07 +00004571 Args.ClaimAllArgs(options::OPT_g_Group);
4572 Args.ClaimAllArgs(options::OPT_emit_llvm);
4573 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4574 // handled somewhere else.
4575 Args.ClaimAllArgs(options::OPT_static_libgcc);
4576
4577 //----------------------------------------------------------------------------
4578 //
4579 //----------------------------------------------------------------------------
4580 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4581 e = ToolChain.ExtraOpts.end();
4582 i != e; ++i)
4583 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004584
Matthew Curtisf10a5952012-12-06 14:16:43 +00004585 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4586 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004587
Matthew Curtise689b052012-12-06 15:46:07 +00004588 if (buildingLib) {
4589 CmdArgs.push_back("-shared");
4590 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4591 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004592 }
4593
Matthew Curtise689b052012-12-06 15:46:07 +00004594 if (hasStaticArg)
4595 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004596
Matthew Curtise8f80a12012-12-06 17:49:03 +00004597 if (buildPIE && !buildingLib)
4598 CmdArgs.push_back("-pie");
4599
4600 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4601 if (!SmallDataThreshold.empty()) {
4602 CmdArgs.push_back(
4603 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4604 }
4605
Matthew Curtise689b052012-12-06 15:46:07 +00004606 //----------------------------------------------------------------------------
4607 //
4608 //----------------------------------------------------------------------------
4609 CmdArgs.push_back("-o");
4610 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004611
Matthew Curtise689b052012-12-06 15:46:07 +00004612 const std::string MarchSuffix = "/" + MarchString;
4613 const std::string G0Suffix = "/G0";
4614 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4615 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4616 + "/";
4617 const std::string StartFilesDir = RootDir
4618 + "hexagon/lib"
4619 + (buildingLib
4620 ? MarchG0Suffix : MarchSuffix);
4621
4622 //----------------------------------------------------------------------------
4623 // moslib
4624 //----------------------------------------------------------------------------
4625 std::vector<std::string> oslibs;
4626 bool hasStandalone= false;
4627
4628 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4629 ie = Args.filtered_end(); it != ie; ++it) {
4630 (*it)->claim();
4631 oslibs.push_back((*it)->getValue());
4632 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004633 }
Matthew Curtise689b052012-12-06 15:46:07 +00004634 if (oslibs.empty()) {
4635 oslibs.push_back("standalone");
4636 hasStandalone = true;
4637 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004638
Matthew Curtise689b052012-12-06 15:46:07 +00004639 //----------------------------------------------------------------------------
4640 // Start Files
4641 //----------------------------------------------------------------------------
4642 if (incStdLib && incStartFiles) {
4643
4644 if (!buildingLib) {
4645 if (hasStandalone) {
4646 CmdArgs.push_back(
4647 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4648 }
4649 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4650 }
4651 std::string initObj = useShared ? "/initS.o" : "/init.o";
4652 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4653 }
4654
4655 //----------------------------------------------------------------------------
4656 // Library Search Paths
4657 //----------------------------------------------------------------------------
4658 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4659 for (ToolChain::path_list::const_iterator
4660 i = LibPaths.begin(),
4661 e = LibPaths.end();
4662 i != e;
4663 ++i)
4664 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4665
4666 //----------------------------------------------------------------------------
4667 //
4668 //----------------------------------------------------------------------------
4669 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4670 Args.AddAllArgs(CmdArgs, options::OPT_e);
4671 Args.AddAllArgs(CmdArgs, options::OPT_s);
4672 Args.AddAllArgs(CmdArgs, options::OPT_t);
4673 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4674
4675 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4676
4677 //----------------------------------------------------------------------------
4678 // Libraries
4679 //----------------------------------------------------------------------------
4680 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004681 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004682 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4683 CmdArgs.push_back("-lm");
4684 }
4685
4686 CmdArgs.push_back("--start-group");
4687
4688 if (!buildingLib) {
4689 for(std::vector<std::string>::iterator i = oslibs.begin(),
4690 e = oslibs.end(); i != e; ++i)
4691 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4692 CmdArgs.push_back("-lc");
4693 }
4694 CmdArgs.push_back("-lgcc");
4695
4696 CmdArgs.push_back("--end-group");
4697 }
4698
4699 //----------------------------------------------------------------------------
4700 // End files
4701 //----------------------------------------------------------------------------
4702 if (incStdLib && incStartFiles) {
4703 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4704 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4705 }
4706
4707 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004708 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004709}
4710// Hexagon tools end.
4711
Bernard Ogden31561762013-12-12 13:27:11 +00004712/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4713//
4714// FIXME: tblgen this.
4715const char *arm::getARMCPUForMArch(const ArgList &Args,
4716 const llvm::Triple &Triple) {
4717 StringRef MArch;
4718 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4719 // Otherwise, if we have -march= choose the base CPU for that arch.
4720 MArch = A->getValue();
4721 } else {
4722 // Otherwise, use the Arch from the triple.
4723 MArch = Triple.getArchName();
4724 }
4725
4726 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004727 if (MArch == "native") {
4728 std::string CPU = llvm::sys::getHostCPUName();
4729 if (CPU != "generic") {
4730 // Translate the native cpu into the architecture. The switch below will
4731 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004732 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004733 }
4734 }
4735
4736 if (Triple.getOS() == llvm::Triple::NetBSD) {
4737 if (MArch == "armv6")
4738 return "arm1176jzf-s";
4739 }
4740
4741 const char *result = llvm::StringSwitch<const char *>(MArch)
4742 .Cases("armv2", "armv2a","arm2")
4743 .Case("armv3", "arm6")
4744 .Case("armv3m", "arm7m")
4745 .Case("armv4", "strongarm")
4746 .Case("armv4t", "arm7tdmi")
4747 .Case("thumbv4t", "arm7tdmi")
4748 .Cases("armv5", "armv5t", "arm10tdmi")
4749 .Cases("thumbv5", "thumbv5t", "arm10tdmi")
4750 .Cases("armv5e", "armv5te", "arm1022e")
4751 .Cases("thumbv5e", "thumbv5te", "arm1022e")
4752 .Case("armv5tej", "arm926ej-s")
4753 .Case("thumbv5tej", "arm926ej-s")
4754 .Cases("armv6", "armv6k", "arm1136jf-s")
4755 .Cases("thumbv6", "thumbv6k", "arm1136jf-s")
4756 .Case("armv6j", "arm1136j-s")
4757 .Case("thumbv6j", "arm1136j-s")
4758 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
4759 .Cases("thumbv6z", "thumbv6zk", "arm1176jzf-s")
4760 .Case("armv6t2", "arm1156t2-s")
4761 .Case("thumbv6t2", "arm1156t2-s")
4762 .Cases("armv6m", "armv6-m", "cortex-m0")
4763 .Case("thumbv6m", "cortex-m0")
4764 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
4765 .Cases("thumbv7", "thumbv7a", "cortex-a8")
4766 .Cases("armv7l", "armv7-l", "cortex-a8")
Bernard Ogden31561762013-12-12 13:27:11 +00004767 .Cases("armv7s", "armv7-s", "swift")
4768 .Cases("armv7r", "armv7-r", "cortex-r4")
4769 .Case("thumbv7r", "cortex-r4")
4770 .Cases("armv7m", "armv7-m", "cortex-m3")
4771 .Case("thumbv7m", "cortex-m3")
4772 .Cases("armv7em", "armv7e-m", "cortex-m4")
4773 .Cases("thumbv7em", "thumbv7e-m", "cortex-m4")
4774 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
4775 .Cases("thumbv8", "thumbv8a", "cortex-a53")
4776 .Case("ep9312", "ep9312")
4777 .Case("iwmmxt", "iwmmxt")
4778 .Case("xscale", "xscale")
4779 // If all else failed, return the most base CPU with thumb interworking
4780 // supported by LLVM.
4781 .Default(0);
4782
4783 if (result)
4784 return result;
4785
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00004786 switch (Triple.getOS()) {
4787 case llvm::Triple::NetBSD:
4788 switch (Triple.getEnvironment()) {
4789 case llvm::Triple::GNUEABIHF:
4790 case llvm::Triple::GNUEABI:
4791 case llvm::Triple::EABIHF:
4792 case llvm::Triple::EABI:
4793 return "arm926ej-s";
4794 default:
4795 return "strongarm";
4796 }
4797 default:
4798 switch (Triple.getEnvironment()) {
4799 case llvm::Triple::EABIHF:
4800 case llvm::Triple::GNUEABIHF:
4801 return "arm1176jzf-s";
4802 default:
4803 return "arm7tdmi";
4804 }
4805 }
Bernard Ogden31561762013-12-12 13:27:11 +00004806}
4807
4808/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00004809StringRef arm::getARMTargetCPU(const ArgList &Args,
4810 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00004811 // FIXME: Warn on inconsistent use of -mcpu and -march.
4812 // If we have -mcpu=, use that.
4813 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
4814 StringRef MCPU = A->getValue();
4815 // Handle -mcpu=native.
4816 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00004817 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00004818 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00004819 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00004820 }
4821
4822 return getARMCPUForMArch(Args, Triple);
4823}
4824
4825/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
4826/// CPU.
4827//
4828// FIXME: This is redundant with -mcpu, why does LLVM use this.
4829// FIXME: tblgen this, or kill it!
4830const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
4831 return llvm::StringSwitch<const char *>(CPU)
4832 .Case("strongarm", "v4")
4833 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
4834 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
4835 .Cases("arm920", "arm920t", "arm922t", "v4t")
4836 .Cases("arm940t", "ep9312","v4t")
4837 .Cases("arm10tdmi", "arm1020t", "v5")
4838 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
4839 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
4840 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
4841 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
4842 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
4843 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00004844 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00004845 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
4846 .Cases("cortex-r4", "cortex-r5", "v7r")
4847 .Case("cortex-m0", "v6m")
4848 .Case("cortex-m3", "v7m")
4849 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00004850 .Case("swift", "v7s")
4851 .Cases("cortex-a53", "cortex-a57", "v8")
4852 .Default("");
4853}
4854
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004855bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
4856 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
4857 return A && (A->getValue() == StringRef(Value));
4858}
4859
Tim Northover157d9112014-01-16 08:48:16 +00004860llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004861 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4862 // archs which Darwin doesn't use.
4863
4864 // The matching this routine does is fairly pointless, since it is neither the
4865 // complete architecture list, nor a reasonable subset. The problem is that
4866 // historically the driver driver accepts this and also ties its -march=
4867 // handling to the architecture name, so we need to be careful before removing
4868 // support for it.
4869
4870 // This code must be kept in sync with Clang's Darwin specific argument
4871 // translation.
4872
4873 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4874 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4875 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4876 .Case("ppc64", llvm::Triple::ppc64)
4877 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4878 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4879 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00004880 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004881 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00004882 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00004883 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00004884 .Cases("armv7s", "xscale", llvm::Triple::arm)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004885 .Case("r600", llvm::Triple::r600)
4886 .Case("nvptx", llvm::Triple::nvptx)
4887 .Case("nvptx64", llvm::Triple::nvptx64)
4888 .Case("amdil", llvm::Triple::amdil)
4889 .Case("spir", llvm::Triple::spir)
4890 .Default(llvm::Triple::UnknownArch);
4891}
Tony Linthicum76329bf2011-12-12 21:14:55 +00004892
Tim Northover157d9112014-01-16 08:48:16 +00004893void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
4894 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
4895 T.setArch(Arch);
4896
4897 if (Str == "x86_64h")
4898 T.setArchName(Str);
4899 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
4900 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00004901 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00004902 }
4903}
4904
Bob Wilsondecc03e2012-11-23 06:14:39 +00004905const char *Clang::getBaseInputName(const ArgList &Args,
4906 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00004907 return Args.MakeArgString(
4908 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004909}
4910
Bob Wilsondecc03e2012-11-23 06:14:39 +00004911const char *Clang::getBaseInputStem(const ArgList &Args,
4912 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004913 const char *Str = getBaseInputName(Args, Inputs);
4914
Chris Lattner906bb902011-01-16 08:14:11 +00004915 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004916 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004917
4918 return Str;
4919}
4920
Bob Wilsondecc03e2012-11-23 06:14:39 +00004921const char *Clang::getDependencyFileName(const ArgList &Args,
4922 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004923 // FIXME: Think about this more.
4924 std::string Res;
4925
4926 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004927 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004928 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004929 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00004930 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004931 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004932 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004933}
4934
Daniel Dunbarbe220842009-03-20 16:06:39 +00004935void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004936 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004937 const InputInfoList &Inputs,
4938 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00004939 const char *LinkingOutput) const {
4940 ArgStringList CmdArgs;
4941
4942 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4943 const InputInfo &Input = Inputs[0];
4944
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004945 // Determine the original source input.
4946 const Action *SourceAction = &JA;
4947 while (SourceAction->getKind() != Action::InputClass) {
4948 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4949 SourceAction = SourceAction->getInputs()[0];
4950 }
4951
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004952 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00004953 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00004954 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
4955 // FIXME: at run-time detect assembler capabilities or rely on version
4956 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004957 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00004958 const llvm::Triple &T(getToolChain().getTriple());
4959 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00004960 CmdArgs.push_back("-Q");
4961 }
Kevin Enderby319baa42013-11-18 23:30:29 +00004962
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004963 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00004964 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004965 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004966 if (Args.hasArg(options::OPT_gstabs))
4967 CmdArgs.push_back("--gstabs");
4968 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00004969 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004970 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004971
Daniel Dunbarbe220842009-03-20 16:06:39 +00004972 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00004973 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00004974
Daniel Dunbar6d484762010-07-22 01:47:22 +00004975 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004976 if (getToolChain().getArch() == llvm::Triple::x86 ||
4977 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00004978 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4979 CmdArgs.push_back("-force_cpusubtype_ALL");
4980
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004981 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004982 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00004983 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00004984 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004985 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004986 CmdArgs.push_back("-static");
4987
Daniel Dunbarbe220842009-03-20 16:06:39 +00004988 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4989 options::OPT_Xassembler);
4990
4991 assert(Output.isFilename() && "Unexpected lipo output.");
4992 CmdArgs.push_back("-o");
4993 CmdArgs.push_back(Output.getFilename());
4994
Daniel Dunbarb440f562010-08-02 02:38:21 +00004995 assert(Input.isFilename() && "Invalid input.");
4996 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00004997
4998 // asm_final spec is empty.
4999
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005000 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005001 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005002 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005003}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005004
Tim Northover157d9112014-01-16 08:48:16 +00005005void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005006
Tim Northover157d9112014-01-16 08:48:16 +00005007void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5008 ArgStringList &CmdArgs) const {
5009 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005010
Daniel Dunbarc1964212009-03-26 16:23:12 +00005011 // Derived from darwin_arch spec.
5012 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005013 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005014
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005015 // FIXME: Is this needed anymore?
5016 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005017 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005018}
5019
Bill Wendling3b2000f2012-10-02 18:02:50 +00005020bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5021 // We only need to generate a temp path for LTO if we aren't compiling object
5022 // files. When compiling source files, we run 'dsymutil' after linking. We
5023 // don't run 'dsymutil' when compiling object files.
5024 for (InputInfoList::const_iterator
5025 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
5026 if (it->getType() != types::TY_Object)
5027 return true;
5028
5029 return false;
5030}
5031
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005032void darwin::Link::AddLinkArgs(Compilation &C,
5033 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005034 ArgStringList &CmdArgs,
5035 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005036 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005037 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005038
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005039 unsigned Version[3] = { 0, 0, 0 };
5040 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5041 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005042 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005043 Version[1], Version[2], HadExtra) ||
5044 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005045 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005046 << A->getAsString(Args);
5047 }
5048
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005049 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005050 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005051 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5052 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005053
Bob Wilson3d27dad2013-08-02 22:25:34 +00005054 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5055 CmdArgs.push_back("-export_dynamic");
5056
Bill Wendling313b6bf2012-11-16 23:03:00 +00005057 // If we are using LTO, then automatically create a temporary file path for
5058 // the linker to use, so that it's lifetime will extend past a possible
5059 // dsymutil step.
5060 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5061 const char *TmpPath = C.getArgs().MakeArgString(
5062 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5063 C.addTempFile(TmpPath);
5064 CmdArgs.push_back("-object_path_lto");
5065 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005066 }
5067
Daniel Dunbarc1964212009-03-26 16:23:12 +00005068 // Derived from the "link" spec.
5069 Args.AddAllArgs(CmdArgs, options::OPT_static);
5070 if (!Args.hasArg(options::OPT_static))
5071 CmdArgs.push_back("-dynamic");
5072 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5073 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5074 // here. How do we wish to handle such things?
5075 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005076
Daniel Dunbarc1964212009-03-26 16:23:12 +00005077 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005078 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005079 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005080 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005081
5082 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5083 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5084 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5085
5086 Arg *A;
5087 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5088 (A = Args.getLastArg(options::OPT_current__version)) ||
5089 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005090 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005091 << A->getAsString(Args) << "-dynamiclib";
5092
5093 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5094 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5095 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5096 } else {
5097 CmdArgs.push_back("-dylib");
5098
5099 Arg *A;
5100 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5101 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5102 (A = Args.getLastArg(options::OPT_client__name)) ||
5103 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5104 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5105 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005106 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005107 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005108
Daniel Dunbarc1964212009-03-26 16:23:12 +00005109 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5110 "-dylib_compatibility_version");
5111 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5112 "-dylib_current_version");
5113
Tim Northover157d9112014-01-16 08:48:16 +00005114 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005115
5116 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5117 "-dylib_install_name");
5118 }
5119
5120 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5121 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5122 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005123 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005124 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005125 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5126 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5127 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5128 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5129 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5130 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005131 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005132 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5133 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5134 Args.AddAllArgs(CmdArgs, options::OPT_init);
5135
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005136 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005137 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005138
Daniel Dunbarc1964212009-03-26 16:23:12 +00005139 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5140 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5141 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5142 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5143 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005144
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005145 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5146 options::OPT_fno_pie,
5147 options::OPT_fno_PIE)) {
5148 if (A->getOption().matches(options::OPT_fpie) ||
5149 A->getOption().matches(options::OPT_fPIE))
5150 CmdArgs.push_back("-pie");
5151 else
5152 CmdArgs.push_back("-no_pie");
5153 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005154
5155 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5156 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5157 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5158 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5159 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5160 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5161 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5162 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5163 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5164 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5165 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5166 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5167 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5168 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5169 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5170 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005171
Daniel Dunbar84384642011-05-02 21:03:47 +00005172 // Give --sysroot= preference, over the Apple specific behavior to also use
5173 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005174 StringRef sysroot = C.getSysRoot();
5175 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005176 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005177 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005178 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5179 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005180 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005181 }
5182
Daniel Dunbarc1964212009-03-26 16:23:12 +00005183 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5184 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5185 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5186 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5187 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005188 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005189 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5190 Args.AddAllArgs(CmdArgs, options::OPT_y);
5191 Args.AddLastArg(CmdArgs, options::OPT_w);
5192 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5193 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5194 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5195 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5196 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5197 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5198 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5199 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5200 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5201 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5202 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5203 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5204}
5205
Alexey Bataev186b28a2014-03-06 05:43:53 +00005206enum LibOpenMP {
5207 LibUnknown,
5208 LibGOMP,
5209 LibIOMP5
5210};
5211
Daniel Dunbarc1964212009-03-26 16:23:12 +00005212void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005213 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005214 const InputInfoList &Inputs,
5215 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005216 const char *LinkingOutput) const {
5217 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005218
Daniel Dunbarc1964212009-03-26 16:23:12 +00005219 // The logic here is derived from gcc's behavior; most of which
5220 // comes from specs (starting with link_command). Consult gcc for
5221 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005222 ArgStringList CmdArgs;
5223
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005224 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5225 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5226 options::OPT_ccc_arcmt_migrate)) {
5227 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
5228 (*I)->claim();
5229 const char *Exec =
5230 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5231 CmdArgs.push_back(Output.getFilename());
5232 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5233 return;
5234 }
5235
Daniel Dunbarc1964212009-03-26 16:23:12 +00005236 // I'm not sure why this particular decomposition exists in gcc, but
5237 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005238 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005239
Daniel Dunbarc1964212009-03-26 16:23:12 +00005240 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5241 Args.AddAllArgs(CmdArgs, options::OPT_s);
5242 Args.AddAllArgs(CmdArgs, options::OPT_t);
5243 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5244 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005245 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005246 Args.AddAllArgs(CmdArgs, options::OPT_r);
5247
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005248 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5249 // members of static archive libraries which implement Objective-C classes or
5250 // categories.
5251 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5252 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005253
Daniel Dunbarc1964212009-03-26 16:23:12 +00005254 CmdArgs.push_back("-o");
5255 CmdArgs.push_back(Output.getFilename());
5256
Chad Rosier06fd3c62012-05-16 23:45:12 +00005257 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005258 !Args.hasArg(options::OPT_nostartfiles))
5259 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005260
5261 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005262
Alexey Bataev186b28a2014-03-06 05:43:53 +00005263 LibOpenMP UsedOpenMPLib = LibUnknown;
5264 if (Args.hasArg(options::OPT_fopenmp)) {
5265 UsedOpenMPLib = LibGOMP;
5266 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5267 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5268 .Case("libgomp", LibGOMP)
5269 .Case("libiomp5", LibIOMP5)
5270 .Default(LibUnknown);
5271 if (UsedOpenMPLib == LibUnknown)
5272 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5273 << A->getOption().getName() << A->getValue();
5274 }
5275 switch (UsedOpenMPLib) {
5276 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005277 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005278 break;
5279 case LibIOMP5:
5280 CmdArgs.push_back("-liomp5");
5281 break;
5282 case LibUnknown:
5283 break;
5284 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005285
Douglas Gregor9295df02012-05-15 21:00:27 +00005286 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5287
Bob Wilson16d93952012-05-15 18:57:39 +00005288 if (isObjCRuntimeLinked(Args) &&
5289 !Args.hasArg(options::OPT_nostdlib) &&
5290 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005291 // We use arclite library for both ARC and subscripting support.
5292 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5293
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005294 CmdArgs.push_back("-framework");
5295 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005296 // Link libobj.
5297 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005298 }
John McCall31168b02011-06-15 23:02:42 +00005299
Daniel Dunbarc1964212009-03-26 16:23:12 +00005300 if (LinkingOutput) {
5301 CmdArgs.push_back("-arch_multiple");
5302 CmdArgs.push_back("-final_output");
5303 CmdArgs.push_back(LinkingOutput);
5304 }
5305
Daniel Dunbarc1964212009-03-26 16:23:12 +00005306 if (Args.hasArg(options::OPT_fnested_functions))
5307 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005308
Daniel Dunbarc1964212009-03-26 16:23:12 +00005309 if (!Args.hasArg(options::OPT_nostdlib) &&
5310 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005311 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005312 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005313
Daniel Dunbarc1964212009-03-26 16:23:12 +00005314 // link_ssp spec is empty.
5315
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005316 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005317 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005318 }
5319
Chad Rosier06fd3c62012-05-16 23:45:12 +00005320 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005321 !Args.hasArg(options::OPT_nostartfiles)) {
5322 // endfile_spec is empty.
5323 }
5324
5325 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5326 Args.AddAllArgs(CmdArgs, options::OPT_F);
5327
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005328 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005329 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005330 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005331}
5332
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005333void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005334 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005335 const InputInfoList &Inputs,
5336 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005337 const char *LinkingOutput) const {
5338 ArgStringList CmdArgs;
5339
5340 CmdArgs.push_back("-create");
5341 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005342
5343 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005344 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005345
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005346 for (InputInfoList::const_iterator
5347 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5348 const InputInfo &II = *it;
5349 assert(II.isFilename() && "Unexpected lipo input.");
5350 CmdArgs.push_back(II.getFilename());
5351 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005352 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005353 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005354 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005355}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005356
Daniel Dunbar88299622010-06-04 18:28:36 +00005357void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005358 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005359 const InputInfoList &Inputs,
5360 const ArgList &Args,
5361 const char *LinkingOutput) const {
5362 ArgStringList CmdArgs;
5363
Daniel Dunbareb86b042011-05-09 17:23:16 +00005364 CmdArgs.push_back("-o");
5365 CmdArgs.push_back(Output.getFilename());
5366
Daniel Dunbar88299622010-06-04 18:28:36 +00005367 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5368 const InputInfo &Input = Inputs[0];
5369 assert(Input.isFilename() && "Unexpected dsymutil input.");
5370 CmdArgs.push_back(Input.getFilename());
5371
Daniel Dunbar88299622010-06-04 18:28:36 +00005372 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005373 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005374 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005375}
5376
Eric Christopher551ef452011-08-23 17:56:55 +00005377void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005378 const InputInfo &Output,
5379 const InputInfoList &Inputs,
5380 const ArgList &Args,
5381 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005382 ArgStringList CmdArgs;
5383 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005384 CmdArgs.push_back("--debug-info");
5385 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005386 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005387
5388 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5389 const InputInfo &Input = Inputs[0];
5390 assert(Input.isFilename() && "Unexpected verify input");
5391
5392 // Grabbing the output of the earlier dsymutil run.
5393 CmdArgs.push_back(Input.getFilename());
5394
5395 const char *Exec =
5396 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5397 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5398}
5399
David Chisnallf571cde2012-02-15 13:39:01 +00005400void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5401 const InputInfo &Output,
5402 const InputInfoList &Inputs,
5403 const ArgList &Args,
5404 const char *LinkingOutput) const {
5405 ArgStringList CmdArgs;
5406
5407 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5408 options::OPT_Xassembler);
5409
5410 CmdArgs.push_back("-o");
5411 CmdArgs.push_back(Output.getFilename());
5412
5413 for (InputInfoList::const_iterator
5414 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5415 const InputInfo &II = *it;
5416 CmdArgs.push_back(II.getFilename());
5417 }
5418
5419 const char *Exec =
5420 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5421 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5422}
5423
5424
5425void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5426 const InputInfo &Output,
5427 const InputInfoList &Inputs,
5428 const ArgList &Args,
5429 const char *LinkingOutput) const {
5430 // FIXME: Find a real GCC, don't hard-code versions here
5431 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5432 const llvm::Triple &T = getToolChain().getTriple();
5433 std::string LibPath = "/usr/lib/";
5434 llvm::Triple::ArchType Arch = T.getArch();
5435 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005436 case llvm::Triple::x86:
5437 GCCLibPath +=
5438 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5439 break;
5440 case llvm::Triple::x86_64:
5441 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5442 GCCLibPath += "/4.5.2/amd64/";
5443 LibPath += "amd64/";
5444 break;
5445 default:
5446 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005447 }
5448
5449 ArgStringList CmdArgs;
5450
David Chisnall272a0712012-02-29 15:06:12 +00005451 // Demangle C++ names in errors
5452 CmdArgs.push_back("-C");
5453
David Chisnallf571cde2012-02-15 13:39:01 +00005454 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5455 (!Args.hasArg(options::OPT_shared))) {
5456 CmdArgs.push_back("-e");
5457 CmdArgs.push_back("_start");
5458 }
5459
5460 if (Args.hasArg(options::OPT_static)) {
5461 CmdArgs.push_back("-Bstatic");
5462 CmdArgs.push_back("-dn");
5463 } else {
5464 CmdArgs.push_back("-Bdynamic");
5465 if (Args.hasArg(options::OPT_shared)) {
5466 CmdArgs.push_back("-shared");
5467 } else {
5468 CmdArgs.push_back("--dynamic-linker");
5469 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5470 }
5471 }
5472
5473 if (Output.isFilename()) {
5474 CmdArgs.push_back("-o");
5475 CmdArgs.push_back(Output.getFilename());
5476 } else {
5477 assert(Output.isNothing() && "Invalid output.");
5478 }
5479
5480 if (!Args.hasArg(options::OPT_nostdlib) &&
5481 !Args.hasArg(options::OPT_nostartfiles)) {
5482 if (!Args.hasArg(options::OPT_shared)) {
5483 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5484 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005485 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005486 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5487 } else {
5488 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005489 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5490 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005491 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005492 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005493 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005494 }
5495
5496 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5497
5498 Args.AddAllArgs(CmdArgs, options::OPT_L);
5499 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5500 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005501 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005502
5503 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5504
5505 if (!Args.hasArg(options::OPT_nostdlib) &&
5506 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005507 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005508 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005509 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005510 if (!Args.hasArg(options::OPT_shared)) {
5511 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005512 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005513 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005514 }
David Chisnallf571cde2012-02-15 13:39:01 +00005515 }
5516
5517 if (!Args.hasArg(options::OPT_nostdlib) &&
5518 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005519 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005520 }
David Chisnall96de9932012-02-16 16:00:47 +00005521 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005522
Alexey Samsonov7811d192014-02-20 13:57:37 +00005523 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005524
5525 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005526 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005527 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5528}
5529
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005530void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005531 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005532 const InputInfoList &Inputs,
5533 const ArgList &Args,
5534 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005535 ArgStringList CmdArgs;
5536
5537 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5538 options::OPT_Xassembler);
5539
5540 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005541 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005542
5543 for (InputInfoList::const_iterator
5544 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5545 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005546 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005547 }
5548
5549 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005550 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005551 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005552}
5553
5554void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005555 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005556 const InputInfoList &Inputs,
5557 const ArgList &Args,
5558 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005559 ArgStringList CmdArgs;
5560
5561 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005562 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005563 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005564 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005565 }
5566
5567 if (Args.hasArg(options::OPT_static)) {
5568 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005569 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005570 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005571// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005572 CmdArgs.push_back("-Bdynamic");
5573 if (Args.hasArg(options::OPT_shared)) {
5574 CmdArgs.push_back("-shared");
5575 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005576 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005577 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5578 }
5579 }
5580
Daniel Dunbarb440f562010-08-02 02:38:21 +00005581 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005582 CmdArgs.push_back("-o");
5583 CmdArgs.push_back(Output.getFilename());
5584 } else {
5585 assert(Output.isNothing() && "Invalid output.");
5586 }
5587
5588 if (!Args.hasArg(options::OPT_nostdlib) &&
5589 !Args.hasArg(options::OPT_nostartfiles)) {
5590 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005591 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005592 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005593 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005594 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005595 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005596 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005597 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005598 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005599 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005600 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005601 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005602 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005603 }
5604
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005605 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5606 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005607 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005608
5609 Args.AddAllArgs(CmdArgs, options::OPT_L);
5610 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5611 Args.AddAllArgs(CmdArgs, options::OPT_e);
5612
Daniel Dunbar54423b22010-09-17 00:24:54 +00005613 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005614
5615 if (!Args.hasArg(options::OPT_nostdlib) &&
5616 !Args.hasArg(options::OPT_nodefaultlibs)) {
5617 // FIXME: For some reason GCC passes -lgcc before adding
5618 // the default system libraries. Just mimic this for now.
5619 CmdArgs.push_back("-lgcc");
5620
5621 if (Args.hasArg(options::OPT_pthread))
5622 CmdArgs.push_back("-pthread");
5623 if (!Args.hasArg(options::OPT_shared))
5624 CmdArgs.push_back("-lc");
5625 CmdArgs.push_back("-lgcc");
5626 }
5627
5628 if (!Args.hasArg(options::OPT_nostdlib) &&
5629 !Args.hasArg(options::OPT_nostartfiles)) {
5630 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005631 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005632 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005633 }
5634
Alexey Samsonov7811d192014-02-20 13:57:37 +00005635 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005636
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005637 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005638 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005639 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005640}
5641
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005642void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005643 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005644 const InputInfoList &Inputs,
5645 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005646 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005647 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005648 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005649
Rafael Espindolacc126272014-02-28 01:55:21 +00005650 switch (getToolChain().getArch()) {
5651 case llvm::Triple::x86:
5652 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5653 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005654 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005655 break;
5656
5657 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005658 CmdArgs.push_back("-mppc");
5659 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005660 break;
5661
5662 case llvm::Triple::sparc:
5663 CmdArgs.push_back("-32");
5664 NeedsKPIC = true;
5665 break;
5666
5667 case llvm::Triple::sparcv9:
5668 CmdArgs.push_back("-64");
5669 CmdArgs.push_back("-Av9a");
5670 NeedsKPIC = true;
5671 break;
5672
5673 case llvm::Triple::mips64:
5674 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005675 StringRef CPUName;
5676 StringRef ABIName;
5677 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5678
5679 CmdArgs.push_back("-mabi");
5680 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5681
5682 if (getToolChain().getArch() == llvm::Triple::mips64)
5683 CmdArgs.push_back("-EB");
5684 else
5685 CmdArgs.push_back("-EL");
5686
Rafael Espindolacc126272014-02-28 01:55:21 +00005687 NeedsKPIC = true;
5688 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005689 }
5690
Rafael Espindolacc126272014-02-28 01:55:21 +00005691 default:
5692 break;
5693 }
5694
5695 if (NeedsKPIC)
5696 addAssemblerKPIC(Args, CmdArgs);
5697
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005698 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5699 options::OPT_Xassembler);
5700
5701 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005702 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005703
5704 for (InputInfoList::const_iterator
5705 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5706 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005707 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005708 }
5709
5710 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005711 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005712 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005713}
5714
5715void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005716 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005717 const InputInfoList &Inputs,
5718 const ArgList &Args,
5719 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005720 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005721 ArgStringList CmdArgs;
5722
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005723 // Silence warning for "clang -g foo.o -o foo"
5724 Args.ClaimAllArgs(options::OPT_g_Group);
5725 // and "clang -emit-llvm foo.o -o foo"
5726 Args.ClaimAllArgs(options::OPT_emit_llvm);
5727 // and for "clang -w foo.o -o foo". Other warning options are already
5728 // handled somewhere else.
5729 Args.ClaimAllArgs(options::OPT_w);
5730
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005731 if (getToolChain().getArch() == llvm::Triple::mips64)
5732 CmdArgs.push_back("-EB");
5733 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5734 CmdArgs.push_back("-EL");
5735
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005736 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005737 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005738 CmdArgs.push_back("-e");
5739 CmdArgs.push_back("__start");
5740 }
5741
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005742 if (Args.hasArg(options::OPT_static)) {
5743 CmdArgs.push_back("-Bstatic");
5744 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005745 if (Args.hasArg(options::OPT_rdynamic))
5746 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005747 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005748 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005749 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005750 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005751 } else {
5752 CmdArgs.push_back("-dynamic-linker");
5753 CmdArgs.push_back("/usr/libexec/ld.so");
5754 }
5755 }
5756
Rafael Espindola044f7832013-06-05 04:28:55 +00005757 if (Args.hasArg(options::OPT_nopie))
5758 CmdArgs.push_back("-nopie");
5759
Daniel Dunbarb440f562010-08-02 02:38:21 +00005760 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005761 CmdArgs.push_back("-o");
5762 CmdArgs.push_back(Output.getFilename());
5763 } else {
5764 assert(Output.isNothing() && "Invalid output.");
5765 }
5766
5767 if (!Args.hasArg(options::OPT_nostdlib) &&
5768 !Args.hasArg(options::OPT_nostartfiles)) {
5769 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00005770 if (Args.hasArg(options::OPT_pg))
5771 CmdArgs.push_back(Args.MakeArgString(
5772 getToolChain().GetFilePath("gcrt0.o")));
5773 else
5774 CmdArgs.push_back(Args.MakeArgString(
5775 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005776 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005777 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005778 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005779 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005780 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005781 }
5782 }
5783
Edward O'Callaghan5c521462009-10-28 15:13:08 +00005784 std::string Triple = getToolChain().getTripleString();
5785 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005786 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005787 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005788 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005789
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005790 Args.AddAllArgs(CmdArgs, options::OPT_L);
5791 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5792 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005793 Args.AddAllArgs(CmdArgs, options::OPT_s);
5794 Args.AddAllArgs(CmdArgs, options::OPT_t);
5795 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5796 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005797
Daniel Dunbar54423b22010-09-17 00:24:54 +00005798 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005799
5800 if (!Args.hasArg(options::OPT_nostdlib) &&
5801 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005802 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005803 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00005804 if (Args.hasArg(options::OPT_pg))
5805 CmdArgs.push_back("-lm_p");
5806 else
5807 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005808 }
5809
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005810 // FIXME: For some reason GCC passes -lgcc before adding
5811 // the default system libraries. Just mimic this for now.
5812 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005813
Eric Christopher17674ec2012-09-13 06:32:34 +00005814 if (Args.hasArg(options::OPT_pthread)) {
5815 if (!Args.hasArg(options::OPT_shared) &&
5816 Args.hasArg(options::OPT_pg))
5817 CmdArgs.push_back("-lpthread_p");
5818 else
5819 CmdArgs.push_back("-lpthread");
5820 }
5821
Chandler Carruth45661652011-12-17 22:32:42 +00005822 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00005823 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00005824 CmdArgs.push_back("-lc_p");
5825 else
5826 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00005827 }
Eric Christopher17674ec2012-09-13 06:32:34 +00005828
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005829 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005830 }
5831
5832 if (!Args.hasArg(options::OPT_nostdlib) &&
5833 !Args.hasArg(options::OPT_nostartfiles)) {
5834 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005835 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005836 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005837 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005838 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005839 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005840 }
5841
5842 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005843 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005844 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005845}
Ed Schoutene33194b2009-04-02 19:13:12 +00005846
Eli Friedman9fa28852012-08-08 23:57:20 +00005847void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5848 const InputInfo &Output,
5849 const InputInfoList &Inputs,
5850 const ArgList &Args,
5851 const char *LinkingOutput) const {
5852 ArgStringList CmdArgs;
5853
5854 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5855 options::OPT_Xassembler);
5856
5857 CmdArgs.push_back("-o");
5858 CmdArgs.push_back(Output.getFilename());
5859
5860 for (InputInfoList::const_iterator
5861 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5862 const InputInfo &II = *it;
5863 CmdArgs.push_back(II.getFilename());
5864 }
5865
5866 const char *Exec =
5867 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5868 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5869}
5870
5871void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5872 const InputInfo &Output,
5873 const InputInfoList &Inputs,
5874 const ArgList &Args,
5875 const char *LinkingOutput) const {
5876 const Driver &D = getToolChain().getDriver();
5877 ArgStringList CmdArgs;
5878
5879 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5880 (!Args.hasArg(options::OPT_shared))) {
5881 CmdArgs.push_back("-e");
5882 CmdArgs.push_back("__start");
5883 }
5884
5885 if (Args.hasArg(options::OPT_static)) {
5886 CmdArgs.push_back("-Bstatic");
5887 } else {
5888 if (Args.hasArg(options::OPT_rdynamic))
5889 CmdArgs.push_back("-export-dynamic");
5890 CmdArgs.push_back("--eh-frame-hdr");
5891 CmdArgs.push_back("-Bdynamic");
5892 if (Args.hasArg(options::OPT_shared)) {
5893 CmdArgs.push_back("-shared");
5894 } else {
5895 CmdArgs.push_back("-dynamic-linker");
5896 CmdArgs.push_back("/usr/libexec/ld.so");
5897 }
5898 }
5899
5900 if (Output.isFilename()) {
5901 CmdArgs.push_back("-o");
5902 CmdArgs.push_back(Output.getFilename());
5903 } else {
5904 assert(Output.isNothing() && "Invalid output.");
5905 }
5906
5907 if (!Args.hasArg(options::OPT_nostdlib) &&
5908 !Args.hasArg(options::OPT_nostartfiles)) {
5909 if (!Args.hasArg(options::OPT_shared)) {
5910 if (Args.hasArg(options::OPT_pg))
5911 CmdArgs.push_back(Args.MakeArgString(
5912 getToolChain().GetFilePath("gcrt0.o")));
5913 else
5914 CmdArgs.push_back(Args.MakeArgString(
5915 getToolChain().GetFilePath("crt0.o")));
5916 CmdArgs.push_back(Args.MakeArgString(
5917 getToolChain().GetFilePath("crtbegin.o")));
5918 } else {
5919 CmdArgs.push_back(Args.MakeArgString(
5920 getToolChain().GetFilePath("crtbeginS.o")));
5921 }
5922 }
5923
5924 Args.AddAllArgs(CmdArgs, options::OPT_L);
5925 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5926 Args.AddAllArgs(CmdArgs, options::OPT_e);
5927
5928 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5929
5930 if (!Args.hasArg(options::OPT_nostdlib) &&
5931 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005932 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00005933 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5934 if (Args.hasArg(options::OPT_pg))
5935 CmdArgs.push_back("-lm_p");
5936 else
5937 CmdArgs.push_back("-lm");
5938 }
5939
Rafael Espindola1ad26f02012-10-23 17:07:31 +00005940 if (Args.hasArg(options::OPT_pthread)) {
5941 if (!Args.hasArg(options::OPT_shared) &&
5942 Args.hasArg(options::OPT_pg))
5943 CmdArgs.push_back("-lpthread_p");
5944 else
5945 CmdArgs.push_back("-lpthread");
5946 }
5947
Eli Friedman9fa28852012-08-08 23:57:20 +00005948 if (!Args.hasArg(options::OPT_shared)) {
5949 if (Args.hasArg(options::OPT_pg))
5950 CmdArgs.push_back("-lc_p");
5951 else
5952 CmdArgs.push_back("-lc");
5953 }
5954
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005955 StringRef MyArch;
5956 switch (getToolChain().getTriple().getArch()) {
5957 case llvm::Triple::arm:
5958 MyArch = "arm";
5959 break;
5960 case llvm::Triple::x86:
5961 MyArch = "i386";
5962 break;
5963 case llvm::Triple::x86_64:
5964 MyArch = "amd64";
5965 break;
5966 default:
5967 llvm_unreachable("Unsupported architecture");
5968 }
5969 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00005970 }
5971
5972 if (!Args.hasArg(options::OPT_nostdlib) &&
5973 !Args.hasArg(options::OPT_nostartfiles)) {
5974 if (!Args.hasArg(options::OPT_shared))
5975 CmdArgs.push_back(Args.MakeArgString(
5976 getToolChain().GetFilePath("crtend.o")));
5977 else
5978 CmdArgs.push_back(Args.MakeArgString(
5979 getToolChain().GetFilePath("crtendS.o")));
5980 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005981
5982 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005983 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005984 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00005985}
5986
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005987void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005988 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005989 const InputInfoList &Inputs,
5990 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005991 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005992 ArgStringList CmdArgs;
5993
Daniel Dunbard854c8d2009-04-01 19:36:32 +00005994 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5995 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005996 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005997 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00005998 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00005999 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006000 else if (getToolChain().getArch() == llvm::Triple::mips ||
6001 getToolChain().getArch() == llvm::Triple::mipsel ||
6002 getToolChain().getArch() == llvm::Triple::mips64 ||
6003 getToolChain().getArch() == llvm::Triple::mips64el) {
6004 StringRef CPUName;
6005 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006006 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006007
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006008 CmdArgs.push_back("-march");
6009 CmdArgs.push_back(CPUName.data());
6010
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006011 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006012 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006013
6014 if (getToolChain().getArch() == llvm::Triple::mips ||
6015 getToolChain().getArch() == llvm::Triple::mips64)
6016 CmdArgs.push_back("-EB");
6017 else
6018 CmdArgs.push_back("-EL");
6019
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006020 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006021 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6022 getToolChain().getArch() == llvm::Triple::thumb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006023 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006024 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006025 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6026
6027 if (FloatABI == "hard") {
6028 CmdArgs.push_back("-mfpu=vfp");
6029 } else {
6030 CmdArgs.push_back("-mfpu=softvfp");
6031 }
6032
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006033 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006034 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006035 case llvm::Triple::GNUEABI:
6036 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006037 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006038 break;
6039
6040 default:
6041 CmdArgs.push_back("-matpcs");
6042 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006043 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006044 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006045 if (getToolChain().getArch() == llvm::Triple::sparc)
6046 CmdArgs.push_back("-Av8plusa");
6047 else
6048 CmdArgs.push_back("-Av9a");
6049
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006050 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006051 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006052
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006053 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6054 options::OPT_Xassembler);
6055
6056 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006057 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006058
6059 for (InputInfoList::const_iterator
6060 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6061 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006062 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006063 }
6064
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006065 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006066 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006067 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006068}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006069
6070void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006071 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006072 const InputInfoList &Inputs,
6073 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006074 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006075 const toolchains::FreeBSD& ToolChain =
6076 static_cast<const toolchains::FreeBSD&>(getToolChain());
6077 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006078 const bool IsPIE =
6079 !Args.hasArg(options::OPT_shared) &&
6080 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006081 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006082
6083 // Silence warning for "clang -g foo.o -o foo"
6084 Args.ClaimAllArgs(options::OPT_g_Group);
6085 // and "clang -emit-llvm foo.o -o foo"
6086 Args.ClaimAllArgs(options::OPT_emit_llvm);
6087 // and for "clang -w foo.o -o foo". Other warning options are already
6088 // handled somewhere else.
6089 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006090
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006091 if (!D.SysRoot.empty())
6092 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6093
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006094 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006095 CmdArgs.push_back("-pie");
6096
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006097 if (Args.hasArg(options::OPT_static)) {
6098 CmdArgs.push_back("-Bstatic");
6099 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006100 if (Args.hasArg(options::OPT_rdynamic))
6101 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006102 CmdArgs.push_back("--eh-frame-hdr");
6103 if (Args.hasArg(options::OPT_shared)) {
6104 CmdArgs.push_back("-Bshareable");
6105 } else {
6106 CmdArgs.push_back("-dynamic-linker");
6107 CmdArgs.push_back("/libexec/ld-elf.so.1");
6108 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006109 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6110 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006111 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6112 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6113 CmdArgs.push_back("--hash-style=both");
6114 }
6115 }
6116 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006117 }
6118
6119 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6120 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006121 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006122 CmdArgs.push_back("-m");
6123 CmdArgs.push_back("elf_i386_fbsd");
6124 }
6125
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006126 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006127 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006128 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006129 }
6130
Daniel Dunbarb440f562010-08-02 02:38:21 +00006131 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006132 CmdArgs.push_back("-o");
6133 CmdArgs.push_back(Output.getFilename());
6134 } else {
6135 assert(Output.isNothing() && "Invalid output.");
6136 }
6137
6138 if (!Args.hasArg(options::OPT_nostdlib) &&
6139 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006140 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006141 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006142 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006143 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006144 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006145 crt1 = "Scrt1.o";
6146 else
6147 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006148 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006149 if (crt1)
6150 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6151
6152 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6153
6154 const char *crtbegin = NULL;
6155 if (Args.hasArg(options::OPT_static))
6156 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006157 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006158 crtbegin = "crtbeginS.o";
6159 else
6160 crtbegin = "crtbegin.o";
6161
6162 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006163 }
6164
6165 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006166 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00006167 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6168 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006169 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006170 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6171 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006172 Args.AddAllArgs(CmdArgs, options::OPT_s);
6173 Args.AddAllArgs(CmdArgs, options::OPT_t);
6174 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6175 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006176
Alp Tokerce365ca2013-12-02 12:43:03 +00006177 if (D.IsUsingLTO(Args))
6178 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006179
Roman Divackyafe2f232012-08-28 15:09:03 +00006180 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006181
6182 if (!Args.hasArg(options::OPT_nostdlib) &&
6183 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006184 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006185 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006186 if (Args.hasArg(options::OPT_pg))
6187 CmdArgs.push_back("-lm_p");
6188 else
6189 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006190 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006191 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6192 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006193 if (Args.hasArg(options::OPT_pg))
6194 CmdArgs.push_back("-lgcc_p");
6195 else
6196 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006197 if (Args.hasArg(options::OPT_static)) {
6198 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006199 } else if (Args.hasArg(options::OPT_pg)) {
6200 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006201 } else {
6202 CmdArgs.push_back("--as-needed");
6203 CmdArgs.push_back("-lgcc_s");
6204 CmdArgs.push_back("--no-as-needed");
6205 }
6206
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006207 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006208 if (Args.hasArg(options::OPT_pg))
6209 CmdArgs.push_back("-lpthread_p");
6210 else
6211 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006212 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006213
Roman Divacky66f22762011-02-10 16:59:40 +00006214 if (Args.hasArg(options::OPT_pg)) {
6215 if (Args.hasArg(options::OPT_shared))
6216 CmdArgs.push_back("-lc");
6217 else
6218 CmdArgs.push_back("-lc_p");
6219 CmdArgs.push_back("-lgcc_p");
6220 } else {
6221 CmdArgs.push_back("-lc");
6222 CmdArgs.push_back("-lgcc");
6223 }
6224
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006225 if (Args.hasArg(options::OPT_static)) {
6226 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006227 } else if (Args.hasArg(options::OPT_pg)) {
6228 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006229 } else {
6230 CmdArgs.push_back("--as-needed");
6231 CmdArgs.push_back("-lgcc_s");
6232 CmdArgs.push_back("--no-as-needed");
6233 }
6234 }
6235
6236 if (!Args.hasArg(options::OPT_nostdlib) &&
6237 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006238 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006239 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006240 else
6241 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006242 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006243 }
6244
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006245 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6246
Alexey Samsonov7811d192014-02-20 13:57:37 +00006247 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006248
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006249 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006250 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006251 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006252}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006253
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006254void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6255 const InputInfo &Output,
6256 const InputInfoList &Inputs,
6257 const ArgList &Args,
6258 const char *LinkingOutput) const {
6259 ArgStringList CmdArgs;
6260
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006261 // GNU as needs different flags for creating the correct output format
6262 // on architectures with different ABIs or optional feature sets.
6263 switch (getToolChain().getArch()) {
6264 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006265 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006266 break;
6267 case llvm::Triple::arm:
6268 case llvm::Triple::thumb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006269 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006270 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006271 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006272 }
6273
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006274 case llvm::Triple::mips:
6275 case llvm::Triple::mipsel:
6276 case llvm::Triple::mips64:
6277 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006278 StringRef CPUName;
6279 StringRef ABIName;
6280 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6281
6282 CmdArgs.push_back("-march");
6283 CmdArgs.push_back(CPUName.data());
6284
6285 CmdArgs.push_back("-mabi");
6286 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6287
6288 if (getToolChain().getArch() == llvm::Triple::mips ||
6289 getToolChain().getArch() == llvm::Triple::mips64)
6290 CmdArgs.push_back("-EB");
6291 else
6292 CmdArgs.push_back("-EL");
6293
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006294 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006295 break;
6296 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006297
6298 case llvm::Triple::sparc:
6299 CmdArgs.push_back("-32");
6300 addAssemblerKPIC(Args, CmdArgs);
6301 break;
6302
6303 case llvm::Triple::sparcv9:
6304 CmdArgs.push_back("-64");
6305 CmdArgs.push_back("-Av9");
6306 addAssemblerKPIC(Args, CmdArgs);
6307 break;
6308
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006309 default:
6310 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006311 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006312
6313 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6314 options::OPT_Xassembler);
6315
6316 CmdArgs.push_back("-o");
6317 CmdArgs.push_back(Output.getFilename());
6318
6319 for (InputInfoList::const_iterator
6320 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6321 const InputInfo &II = *it;
6322 CmdArgs.push_back(II.getFilename());
6323 }
6324
David Chisnallddbd68f2011-09-27 22:03:18 +00006325 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006326 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6327}
6328
6329void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6330 const InputInfo &Output,
6331 const InputInfoList &Inputs,
6332 const ArgList &Args,
6333 const char *LinkingOutput) const {
6334 const Driver &D = getToolChain().getDriver();
6335 ArgStringList CmdArgs;
6336
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006337 if (!D.SysRoot.empty())
6338 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6339
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006340 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006341 if (Args.hasArg(options::OPT_static)) {
6342 CmdArgs.push_back("-Bstatic");
6343 } else {
6344 if (Args.hasArg(options::OPT_rdynamic))
6345 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006346 if (Args.hasArg(options::OPT_shared)) {
6347 CmdArgs.push_back("-Bshareable");
6348 } else {
6349 CmdArgs.push_back("-dynamic-linker");
6350 CmdArgs.push_back("/libexec/ld.elf_so");
6351 }
6352 }
6353
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006354 // Many NetBSD architectures support more than one ABI.
6355 // Determine the correct emulation for ld.
6356 switch (getToolChain().getArch()) {
6357 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006358 CmdArgs.push_back("-m");
6359 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006360 break;
6361 case llvm::Triple::arm:
6362 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006363 CmdArgs.push_back("-m");
6364 switch (getToolChain().getTriple().getEnvironment()) {
6365 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006366 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006367 CmdArgs.push_back("armelf_nbsd_eabi");
6368 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006369 case llvm::Triple::EABIHF:
6370 case llvm::Triple::GNUEABIHF:
6371 CmdArgs.push_back("armelf_nbsd_eabihf");
6372 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006373 default:
6374 CmdArgs.push_back("armelf_nbsd");
6375 break;
6376 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006377 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006378 case llvm::Triple::mips64:
6379 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006380 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006381 CmdArgs.push_back("-m");
6382 if (getToolChain().getArch() == llvm::Triple::mips64)
6383 CmdArgs.push_back("elf32btsmip");
6384 else
6385 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006386 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006387 CmdArgs.push_back("-m");
6388 if (getToolChain().getArch() == llvm::Triple::mips64)
6389 CmdArgs.push_back("elf64btsmip");
6390 else
6391 CmdArgs.push_back("elf64ltsmip");
6392 }
6393 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006394
6395 case llvm::Triple::sparc:
6396 CmdArgs.push_back("-m");
6397 CmdArgs.push_back("elf32_sparc");
6398 break;
6399
6400 case llvm::Triple::sparcv9:
6401 CmdArgs.push_back("-m");
6402 CmdArgs.push_back("elf64_sparc");
6403 break;
6404
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006405 default:
6406 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006407 }
6408
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006409 if (Output.isFilename()) {
6410 CmdArgs.push_back("-o");
6411 CmdArgs.push_back(Output.getFilename());
6412 } else {
6413 assert(Output.isNothing() && "Invalid output.");
6414 }
6415
6416 if (!Args.hasArg(options::OPT_nostdlib) &&
6417 !Args.hasArg(options::OPT_nostartfiles)) {
6418 if (!Args.hasArg(options::OPT_shared)) {
6419 CmdArgs.push_back(Args.MakeArgString(
6420 getToolChain().GetFilePath("crt0.o")));
6421 CmdArgs.push_back(Args.MakeArgString(
6422 getToolChain().GetFilePath("crti.o")));
6423 CmdArgs.push_back(Args.MakeArgString(
6424 getToolChain().GetFilePath("crtbegin.o")));
6425 } else {
6426 CmdArgs.push_back(Args.MakeArgString(
6427 getToolChain().GetFilePath("crti.o")));
6428 CmdArgs.push_back(Args.MakeArgString(
6429 getToolChain().GetFilePath("crtbeginS.o")));
6430 }
6431 }
6432
6433 Args.AddAllArgs(CmdArgs, options::OPT_L);
6434 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6435 Args.AddAllArgs(CmdArgs, options::OPT_e);
6436 Args.AddAllArgs(CmdArgs, options::OPT_s);
6437 Args.AddAllArgs(CmdArgs, options::OPT_t);
6438 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6439 Args.AddAllArgs(CmdArgs, options::OPT_r);
6440
6441 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6442
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006443 unsigned Major, Minor, Micro;
6444 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6445 bool useLibgcc = true;
6446 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006447 switch(getToolChain().getArch()) {
6448 case llvm::Triple::x86:
6449 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006450 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006451 break;
6452 default:
6453 break;
6454 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006455 }
6456
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006457 if (!Args.hasArg(options::OPT_nostdlib) &&
6458 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006459 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006460 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6461 CmdArgs.push_back("-lm");
6462 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006463 if (Args.hasArg(options::OPT_pthread))
6464 CmdArgs.push_back("-lpthread");
6465 CmdArgs.push_back("-lc");
6466
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006467 if (useLibgcc) {
6468 if (Args.hasArg(options::OPT_static)) {
6469 // libgcc_eh depends on libc, so resolve as much as possible,
6470 // pull in any new requirements from libc and then get the rest
6471 // of libgcc.
6472 CmdArgs.push_back("-lgcc_eh");
6473 CmdArgs.push_back("-lc");
6474 CmdArgs.push_back("-lgcc");
6475 } else {
6476 CmdArgs.push_back("-lgcc");
6477 CmdArgs.push_back("--as-needed");
6478 CmdArgs.push_back("-lgcc_s");
6479 CmdArgs.push_back("--no-as-needed");
6480 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006481 }
6482 }
6483
6484 if (!Args.hasArg(options::OPT_nostdlib) &&
6485 !Args.hasArg(options::OPT_nostartfiles)) {
6486 if (!Args.hasArg(options::OPT_shared))
6487 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6488 "crtend.o")));
6489 else
6490 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6491 "crtendS.o")));
6492 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6493 "crtn.o")));
6494 }
6495
Alexey Samsonov7811d192014-02-20 13:57:37 +00006496 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006497
Rafael Espindola236db462013-11-09 20:07:19 +00006498 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006499 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6500}
6501
Thomas Schwinge4e555262013-03-28 19:04:25 +00006502void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6503 const InputInfo &Output,
6504 const InputInfoList &Inputs,
6505 const ArgList &Args,
6506 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006507 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006508 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006509
6510 // Add --32/--64 to make sure we get the format we want.
6511 // This is incomplete
6512 if (getToolChain().getArch() == llvm::Triple::x86) {
6513 CmdArgs.push_back("--32");
6514 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6515 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006516 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6517 CmdArgs.push_back("-a32");
6518 CmdArgs.push_back("-mppc");
6519 CmdArgs.push_back("-many");
6520 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6521 CmdArgs.push_back("-a64");
6522 CmdArgs.push_back("-mppc64");
6523 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006524 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6525 CmdArgs.push_back("-a64");
6526 CmdArgs.push_back("-mppc64le");
6527 CmdArgs.push_back("-many");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006528 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6529 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006530 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006531 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006532 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6533 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006534 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006535 NeedsKPIC = true;
Rafael Espindola92b00932010-08-10 00:25:48 +00006536 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006537 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006538 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6539 CmdArgs.push_back("-mfpu=neon");
Bernard Ogdena58ef052013-10-24 18:32:41 +00006540 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6541 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006542
Tim Northover9c7e0352013-12-12 11:55:52 +00006543 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6544 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006545 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006546
6547 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006548
6549 // FIXME: remove krait check when GNU tools support krait cpu
6550 // for now replace it with -march=armv7-a to avoid a lower
6551 // march from being picked in the absence of a cpu flag.
6552 Arg *A;
6553 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6554 StringRef(A->getValue()) == "krait")
6555 CmdArgs.push_back("-march=armv7-a");
6556 else
6557 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006558 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006559 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6560 getToolChain().getArch() == llvm::Triple::mipsel ||
6561 getToolChain().getArch() == llvm::Triple::mips64 ||
6562 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006563 StringRef CPUName;
6564 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006565 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006566
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006567 CmdArgs.push_back("-march");
6568 CmdArgs.push_back(CPUName.data());
6569
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006570 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006571 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006572
6573 if (getToolChain().getArch() == llvm::Triple::mips ||
6574 getToolChain().getArch() == llvm::Triple::mips64)
6575 CmdArgs.push_back("-EB");
6576 else
6577 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006578
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006579 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6580 if (StringRef(A->getValue()) == "2008")
6581 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6582 }
6583
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006584 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006585 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6586 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6587 options::OPT_mno_micromips);
6588 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6589 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6590
Simon Atanasyanbd986632013-11-26 11:58:04 +00006591 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6592 // Do not use AddLastArg because not all versions of MIPS assembler
6593 // support -mmsa / -mno-msa options.
6594 if (A->getOption().matches(options::OPT_mmsa))
6595 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6596 }
6597
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006598 NeedsKPIC = true;
6599 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6600 // Always pass an -march option, since our default of z10 is later
6601 // than the GNU assembler's default.
6602 StringRef CPUName = getSystemZTargetCPU(Args);
6603 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6604 }
6605
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006606 if (NeedsKPIC)
6607 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006608
6609 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6610 options::OPT_Xassembler);
6611
6612 CmdArgs.push_back("-o");
6613 CmdArgs.push_back(Output.getFilename());
6614
6615 for (InputInfoList::const_iterator
6616 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6617 const InputInfo &II = *it;
6618 CmdArgs.push_back(II.getFilename());
6619 }
6620
6621 const char *Exec =
6622 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6623 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006624
6625 // Handle the debug info splitting at object creation time if we're
6626 // creating an object.
6627 // TODO: Currently only works on linux with newer objcopy.
6628 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006629 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006630 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6631 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006632}
6633
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006634static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006635 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006636 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006637 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6638 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006639 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006640 CmdArgs.push_back("-lgcc");
6641
Logan Chien3d3373c2012-11-19 12:04:11 +00006642 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006643 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006644 CmdArgs.push_back("-lgcc");
6645 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006646 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006647 CmdArgs.push_back("--as-needed");
6648 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006649 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006650 CmdArgs.push_back("--no-as-needed");
6651 }
6652
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006653 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006654 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006655 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006656 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006657
6658 // According to Android ABI, we have to link with libdl if we are
6659 // linking with non-static libgcc.
6660 //
6661 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6662 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6663 if (isAndroid && !StaticLibgcc)
6664 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006665}
6666
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006667static StringRef getLinuxDynamicLinker(const ArgList &Args,
6668 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006669 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6670 if (ToolChain.getTriple().isArch64Bit())
6671 return "/system/bin/linker64";
6672 else
6673 return "/system/bin/linker";
6674 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6675 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006676 return "/lib/ld-linux.so.2";
6677 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6678 return "/lib/ld-linux-aarch64.so.1";
Christian Pirkera74c7912014-03-14 12:15:45 +00006679 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6680 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006681 else if (ToolChain.getArch() == llvm::Triple::arm ||
6682 ToolChain.getArch() == llvm::Triple::thumb) {
6683 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6684 return "/lib/ld-linux-armhf.so.3";
6685 else
6686 return "/lib/ld-linux.so.3";
6687 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6688 ToolChain.getArch() == llvm::Triple::mipsel)
6689 return "/lib/ld.so.1";
6690 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6691 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006692 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006693 return "/lib32/ld.so.1";
6694 else
6695 return "/lib64/ld.so.1";
6696 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6697 return "/lib/ld.so.1";
6698 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidt778d3872013-07-26 01:36:11 +00006699 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006700 ToolChain.getArch() == llvm::Triple::systemz)
6701 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006702 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6703 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006704 else
6705 return "/lib64/ld-linux-x86-64.so.2";
6706}
6707
Renato Golinc4b49242014-02-13 10:01:16 +00006708static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6709 ArgStringList &CmdArgs, const ArgList &Args) {
6710 // Make use of compiler-rt if --rtlib option is used
6711 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6712
6713 switch(RLT) {
6714 case ToolChain::RLT_CompilerRT:
6715 addClangRTLinux(TC, Args, CmdArgs);
6716 break;
6717 case ToolChain::RLT_Libgcc:
6718 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6719 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006720 }
6721}
6722
Thomas Schwinge4e555262013-03-28 19:04:25 +00006723void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6724 const InputInfo &Output,
6725 const InputInfoList &Inputs,
6726 const ArgList &Args,
6727 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006728 const toolchains::Linux& ToolChain =
6729 static_cast<const toolchains::Linux&>(getToolChain());
6730 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006731 const bool isAndroid =
6732 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006733 const bool IsPIE =
6734 !Args.hasArg(options::OPT_shared) &&
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006735 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006736
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006737 ArgStringList CmdArgs;
6738
Rafael Espindolad1002f62010-11-15 18:28:16 +00006739 // Silence warning for "clang -g foo.o -o foo"
6740 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006741 // and "clang -emit-llvm foo.o -o foo"
6742 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00006743 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00006744 // handled somewhere else.
6745 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00006746
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006747 if (!D.SysRoot.empty())
6748 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006749
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006750 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00006751 CmdArgs.push_back("-pie");
6752
Rafael Espindola1c76c592010-11-07 22:57:16 +00006753 if (Args.hasArg(options::OPT_rdynamic))
6754 CmdArgs.push_back("-export-dynamic");
6755
Rafael Espindola34d77dc2010-11-11 19:34:42 +00006756 if (Args.hasArg(options::OPT_s))
6757 CmdArgs.push_back("-s");
6758
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006759 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6760 e = ToolChain.ExtraOpts.end();
6761 i != e; ++i)
6762 CmdArgs.push_back(i->c_str());
6763
6764 if (!Args.hasArg(options::OPT_static)) {
6765 CmdArgs.push_back("--eh-frame-hdr");
6766 }
6767
6768 CmdArgs.push_back("-m");
6769 if (ToolChain.getArch() == llvm::Triple::x86)
6770 CmdArgs.push_back("elf_i386");
Tim Northover9bb857a2013-01-31 12:13:10 +00006771 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6772 CmdArgs.push_back("aarch64linux");
Christian Pirkera74c7912014-03-14 12:15:45 +00006773 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6774 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00006775 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00006776 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006777 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00006778 else if (ToolChain.getArch() == llvm::Triple::ppc)
6779 CmdArgs.push_back("elf32ppclinux");
6780 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6781 CmdArgs.push_back("elf64ppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00006782 else if (ToolChain.getArch() == llvm::Triple::sparc)
6783 CmdArgs.push_back("elf32_sparc");
6784 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6785 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00006786 else if (ToolChain.getArch() == llvm::Triple::mips)
6787 CmdArgs.push_back("elf32btsmip");
6788 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6789 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006790 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006791 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006792 CmdArgs.push_back("elf32btsmipn32");
6793 else
6794 CmdArgs.push_back("elf64btsmip");
6795 }
6796 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006797 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006798 CmdArgs.push_back("elf32ltsmipn32");
6799 else
6800 CmdArgs.push_back("elf64ltsmip");
6801 }
Ulrich Weigand47445072013-05-06 16:26:41 +00006802 else if (ToolChain.getArch() == llvm::Triple::systemz)
6803 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006804 else
6805 CmdArgs.push_back("elf_x86_64");
6806
6807 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00006808 if (ToolChain.getArch() == llvm::Triple::arm ||
6809 ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006810 CmdArgs.push_back("-Bstatic");
6811 else
6812 CmdArgs.push_back("-static");
6813 } else if (Args.hasArg(options::OPT_shared)) {
6814 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00006815 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006816 CmdArgs.push_back("-Bsymbolic");
6817 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006818 }
6819
6820 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00006821 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006822 (!Args.hasArg(options::OPT_static) &&
6823 !Args.hasArg(options::OPT_shared))) {
6824 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006825 CmdArgs.push_back(Args.MakeArgString(
6826 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006827 }
6828
6829 CmdArgs.push_back("-o");
6830 CmdArgs.push_back(Output.getFilename());
6831
Rafael Espindola81937ec2010-12-01 01:52:43 +00006832 if (!Args.hasArg(options::OPT_nostdlib) &&
6833 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006834 if (!isAndroid) {
6835 const char *crt1 = NULL;
6836 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00006837 if (Args.hasArg(options::OPT_pg))
6838 crt1 = "gcrt1.o";
6839 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006840 crt1 = "Scrt1.o";
6841 else
6842 crt1 = "crt1.o";
6843 }
6844 if (crt1)
6845 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006846
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006847 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6848 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006849
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006850 const char *crtbegin;
6851 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006852 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006853 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006854 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006855 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006856 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006857 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006858 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006859 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00006860
6861 // Add crtfastmath.o if available and fast math is enabled.
6862 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006863 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006864
6865 Args.AddAllArgs(CmdArgs, options::OPT_L);
6866
6867 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6868
Roman Divackyee8188a2011-03-01 17:53:14 +00006869 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6870 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006871 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006872
Alp Tokerce365ca2013-12-02 12:43:03 +00006873 if (D.IsUsingLTO(Args))
6874 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00006875
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00006876 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6877 CmdArgs.push_back("--no-demangle");
6878
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006879 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6880
Alexey Samsonovce8ab102014-02-25 12:43:43 +00006881 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006882 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00006883 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006884
Hans Wennborg70850d82013-07-18 20:29:38 +00006885 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00006886 !Args.hasArg(options::OPT_nostdlib) &&
6887 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00006888 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6889 !Args.hasArg(options::OPT_static);
6890 if (OnlyLibstdcxxStatic)
6891 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006892 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00006893 if (OnlyLibstdcxxStatic)
6894 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006895 CmdArgs.push_back("-lm");
6896 }
6897
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006898 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00006899 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6900 if (Args.hasArg(options::OPT_static))
6901 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00006902
Alexey Bataev186b28a2014-03-06 05:43:53 +00006903 LibOpenMP UsedOpenMPLib = LibUnknown;
6904 if (Args.hasArg(options::OPT_fopenmp)) {
6905 UsedOpenMPLib = LibGOMP;
6906 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
6907 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
6908 .Case("libgomp", LibGOMP)
6909 .Case("libiomp5", LibIOMP5)
6910 .Default(LibUnknown);
6911 if (UsedOpenMPLib == LibUnknown)
6912 D.Diag(diag::err_drv_unsupported_option_argument)
6913 << A->getOption().getName() << A->getValue();
6914 }
6915 switch (UsedOpenMPLib) {
6916 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00006917 CmdArgs.push_back("-lgomp");
6918
Alp Tokerf6a24ce2013-12-05 16:25:25 +00006919 // FIXME: Exclude this for platforms with libgomp that don't require
6920 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00006921 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00006922 break;
6923 case LibIOMP5:
6924 CmdArgs.push_back("-liomp5");
6925 break;
6926 case LibUnknown:
6927 break;
Chandler Carruth01538002013-01-17 13:19:29 +00006928 }
Renato Golinc4b49242014-02-13 10:01:16 +00006929 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006930
Chandler Carruth94a32012012-05-14 18:31:18 +00006931 if (Args.hasArg(options::OPT_pthread) ||
Alexey Bataev648250a2014-03-07 07:43:52 +00006932 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown)
Chandler Carruth94a32012012-05-14 18:31:18 +00006933 CmdArgs.push_back("-lpthread");
6934
6935 CmdArgs.push_back("-lc");
6936
6937 if (Args.hasArg(options::OPT_static))
6938 CmdArgs.push_back("--end-group");
6939 else
Renato Golinc4b49242014-02-13 10:01:16 +00006940 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00006941 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00006942
Rafael Espindola81937ec2010-12-01 01:52:43 +00006943 if (!Args.hasArg(options::OPT_nostartfiles)) {
6944 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006945 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006946 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006947 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006948 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00006949 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006950 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006951
Rafael Espindola81937ec2010-12-01 01:52:43 +00006952 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006953 if (!isAndroid)
6954 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00006955 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006956 }
6957
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006958 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6959}
Rafael Espindola92b00932010-08-10 00:25:48 +00006960
Chris Lattner3e2ee142010-07-07 16:01:42 +00006961void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006962 const InputInfo &Output,
6963 const InputInfoList &Inputs,
6964 const ArgList &Args,
6965 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006966 ArgStringList CmdArgs;
6967
6968 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6969 options::OPT_Xassembler);
6970
6971 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006972 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006973
6974 for (InputInfoList::const_iterator
6975 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6976 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006977 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006978 }
6979
6980 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00006981 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006982 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006983}
6984
6985void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006986 const InputInfo &Output,
6987 const InputInfoList &Inputs,
6988 const ArgList &Args,
6989 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006990 const Driver &D = getToolChain().getDriver();
6991 ArgStringList CmdArgs;
6992
Daniel Dunbarb440f562010-08-02 02:38:21 +00006993 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006994 CmdArgs.push_back("-o");
6995 CmdArgs.push_back(Output.getFilename());
6996 } else {
6997 assert(Output.isNothing() && "Invalid output.");
6998 }
6999
7000 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007001 !Args.hasArg(options::OPT_nostartfiles)) {
7002 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7003 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7004 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7005 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7006 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007007
7008 Args.AddAllArgs(CmdArgs, options::OPT_L);
7009 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7010 Args.AddAllArgs(CmdArgs, options::OPT_e);
7011
Daniel Dunbar54423b22010-09-17 00:24:54 +00007012 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007013
Alexey Samsonov7811d192014-02-20 13:57:37 +00007014 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007015
Chris Lattner3e2ee142010-07-07 16:01:42 +00007016 if (!Args.hasArg(options::OPT_nostdlib) &&
7017 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007018 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007019 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007020 CmdArgs.push_back("-lm");
7021 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007022 }
7023
7024 if (!Args.hasArg(options::OPT_nostdlib) &&
7025 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007026 if (Args.hasArg(options::OPT_pthread))
7027 CmdArgs.push_back("-lpthread");
7028 CmdArgs.push_back("-lc");
7029 CmdArgs.push_back("-lCompilerRT-Generic");
7030 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7031 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007032 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007033 }
7034
Rafael Espindola236db462013-11-09 20:07:19 +00007035 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007036 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007037}
7038
Daniel Dunbarcc912342009-05-02 18:28:39 +00007039/// DragonFly Tools
7040
7041// For now, DragonFly Assemble does just about the same as for
7042// FreeBSD, but this may change soon.
7043void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007044 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007045 const InputInfoList &Inputs,
7046 const ArgList &Args,
7047 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007048 ArgStringList CmdArgs;
7049
7050 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7051 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007052 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007053 CmdArgs.push_back("--32");
7054
7055 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7056 options::OPT_Xassembler);
7057
7058 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007059 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007060
7061 for (InputInfoList::const_iterator
7062 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7063 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007064 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007065 }
7066
7067 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007068 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007069 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007070}
7071
7072void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007073 const InputInfo &Output,
7074 const InputInfoList &Inputs,
7075 const ArgList &Args,
7076 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007077 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007078 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007079 ArgStringList CmdArgs;
7080
John McCall65b8da02013-04-11 22:55:55 +00007081 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7082 UseGCC47 = false;
7083
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007084 if (!D.SysRoot.empty())
7085 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7086
John McCall65b8da02013-04-11 22:55:55 +00007087 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007088 if (Args.hasArg(options::OPT_static)) {
7089 CmdArgs.push_back("-Bstatic");
7090 } else {
John McCall65b8da02013-04-11 22:55:55 +00007091 if (Args.hasArg(options::OPT_rdynamic))
7092 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007093 if (Args.hasArg(options::OPT_shared))
7094 CmdArgs.push_back("-Bshareable");
7095 else {
7096 CmdArgs.push_back("-dynamic-linker");
7097 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7098 }
John McCall65b8da02013-04-11 22:55:55 +00007099 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007100 }
7101
7102 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7103 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007104 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007105 CmdArgs.push_back("-m");
7106 CmdArgs.push_back("elf_i386");
7107 }
7108
Daniel Dunbarb440f562010-08-02 02:38:21 +00007109 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007110 CmdArgs.push_back("-o");
7111 CmdArgs.push_back(Output.getFilename());
7112 } else {
7113 assert(Output.isNothing() && "Invalid output.");
7114 }
7115
7116 if (!Args.hasArg(options::OPT_nostdlib) &&
7117 !Args.hasArg(options::OPT_nostartfiles)) {
7118 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007119 if (Args.hasArg(options::OPT_pg))
7120 CmdArgs.push_back(Args.MakeArgString(
7121 getToolChain().GetFilePath("gcrt1.o")));
7122 else {
7123 if (Args.hasArg(options::OPT_pie))
7124 CmdArgs.push_back(Args.MakeArgString(
7125 getToolChain().GetFilePath("Scrt1.o")));
7126 else
7127 CmdArgs.push_back(Args.MakeArgString(
7128 getToolChain().GetFilePath("crt1.o")));
7129 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007130 }
John McCall65b8da02013-04-11 22:55:55 +00007131 CmdArgs.push_back(Args.MakeArgString(
7132 getToolChain().GetFilePath("crti.o")));
7133 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7134 CmdArgs.push_back(Args.MakeArgString(
7135 getToolChain().GetFilePath("crtbeginS.o")));
7136 else
7137 CmdArgs.push_back(Args.MakeArgString(
7138 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007139 }
7140
7141 Args.AddAllArgs(CmdArgs, options::OPT_L);
7142 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7143 Args.AddAllArgs(CmdArgs, options::OPT_e);
7144
Daniel Dunbar54423b22010-09-17 00:24:54 +00007145 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007146
7147 if (!Args.hasArg(options::OPT_nostdlib) &&
7148 !Args.hasArg(options::OPT_nodefaultlibs)) {
7149 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7150 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007151 if (UseGCC47)
7152 CmdArgs.push_back("-L/usr/lib/gcc47");
7153 else
7154 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007155
7156 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007157 if (UseGCC47) {
7158 CmdArgs.push_back("-rpath");
7159 CmdArgs.push_back("/usr/lib/gcc47");
7160 } else {
7161 CmdArgs.push_back("-rpath");
7162 CmdArgs.push_back("/usr/lib/gcc44");
7163 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007164 }
7165
Hans Wennborg70850d82013-07-18 20:29:38 +00007166 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007167 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007168 CmdArgs.push_back("-lm");
7169 }
7170
Daniel Dunbarcc912342009-05-02 18:28:39 +00007171 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007172 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007173
7174 if (!Args.hasArg(options::OPT_nolibc)) {
7175 CmdArgs.push_back("-lc");
7176 }
7177
John McCall65b8da02013-04-11 22:55:55 +00007178 if (UseGCC47) {
7179 if (Args.hasArg(options::OPT_static) ||
7180 Args.hasArg(options::OPT_static_libgcc)) {
7181 CmdArgs.push_back("-lgcc");
7182 CmdArgs.push_back("-lgcc_eh");
7183 } else {
7184 if (Args.hasArg(options::OPT_shared_libgcc)) {
7185 CmdArgs.push_back("-lgcc_pic");
7186 if (!Args.hasArg(options::OPT_shared))
7187 CmdArgs.push_back("-lgcc");
7188 } else {
7189 CmdArgs.push_back("-lgcc");
7190 CmdArgs.push_back("--as-needed");
7191 CmdArgs.push_back("-lgcc_pic");
7192 CmdArgs.push_back("--no-as-needed");
7193 }
7194 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007195 } else {
John McCall65b8da02013-04-11 22:55:55 +00007196 if (Args.hasArg(options::OPT_shared)) {
7197 CmdArgs.push_back("-lgcc_pic");
7198 } else {
7199 CmdArgs.push_back("-lgcc");
7200 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007201 }
7202 }
7203
7204 if (!Args.hasArg(options::OPT_nostdlib) &&
7205 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007206 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007207 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007208 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007209 else
7210 CmdArgs.push_back(Args.MakeArgString(
7211 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007212 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007213 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007214 }
7215
Alexey Samsonov7811d192014-02-20 13:57:37 +00007216 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007217
Daniel Dunbarcc912342009-05-02 18:28:39 +00007218 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00007219 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007220 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007221}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007222
7223void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7224 const InputInfo &Output,
7225 const InputInfoList &Inputs,
7226 const ArgList &Args,
7227 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007228 ArgStringList CmdArgs;
7229
7230 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007231 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7232 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007233 } else {
7234 assert(Output.isNothing() && "Invalid output.");
7235 }
7236
7237 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007238 !Args.hasArg(options::OPT_nostartfiles) &&
7239 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007240 CmdArgs.push_back("-defaultlib:libcmt");
7241 }
7242
7243 CmdArgs.push_back("-nologo");
7244
Hans Wennborgf1a74252013-09-10 20:18:04 +00007245 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7246
7247 if (DLL) {
7248 CmdArgs.push_back(Args.MakeArgString("-dll"));
7249
7250 SmallString<128> ImplibName(Output.getFilename());
7251 llvm::sys::path::replace_extension(ImplibName, "lib");
7252 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7253 ImplibName.str()));
7254 }
7255
Peter Collingbourne32701642013-11-01 18:16:25 +00007256 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007257 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007258 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborg65f17522013-08-27 18:10:21 +00007259 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007260 llvm::sys::path::append(LibSanitizer, "lib", "windows");
7261 if (DLL) {
Timur Iskhodzhanov3b6adcb62013-09-11 11:45:31 +00007262 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
Hans Wennborgf1a74252013-09-10 20:18:04 +00007263 } else {
7264 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
7265 }
7266 // FIXME: Handle 64-bit.
Hans Wennborg65f17522013-08-27 18:10:21 +00007267 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7268 }
7269
Michael J. Spencere2f49362012-06-18 16:56:04 +00007270 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007271 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007272
7273 // Add filenames immediately.
7274 for (InputInfoList::const_iterator
7275 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7276 if (it->isFilename())
7277 CmdArgs.push_back(it->getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007278 else
7279 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007280 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007281
7282 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007283 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007284 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7285}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007286
7287void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7288 const InputInfo &Output,
7289 const InputInfoList &Inputs,
7290 const ArgList &Args,
7291 const char *LinkingOutput) const {
7292 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7293}
7294
Hans Wennborg188382e2013-09-20 18:16:35 +00007295// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7296// If one cannot be found, return FallbackName.
7297// We do this special search to prevent clang-cl from falling back onto itself
7298// if it's available as cl.exe on the path.
7299static std::string FindFallback(const char *FallbackName,
7300 const char *ClangProgramPath) {
7301 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7302 if (!OptPath.hasValue())
7303 return FallbackName;
7304
7305#ifdef LLVM_ON_WIN32
7306 const StringRef PathSeparators = ";";
7307#else
7308 const StringRef PathSeparators = ":";
7309#endif
7310
7311 SmallVector<StringRef, 8> PathSegments;
7312 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7313
7314 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7315 const StringRef &PathSegment = PathSegments[i];
7316 if (PathSegment.empty())
7317 continue;
7318
7319 SmallString<128> FilePath(PathSegment);
7320 llvm::sys::path::append(FilePath, FallbackName);
7321 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7322 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7323 return FilePath.str();
7324 }
7325
7326 return FallbackName;
7327}
7328
Hans Wennborg87cfa712013-09-19 20:32:16 +00007329Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7330 const InputInfo &Output,
7331 const InputInfoList &Inputs,
7332 const ArgList &Args,
7333 const char *LinkingOutput) const {
7334 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007335 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007336 CmdArgs.push_back("/c"); // Compile only.
7337 CmdArgs.push_back("/W0"); // No warnings.
7338
7339 // The goal is to be able to invoke this tool correctly based on
7340 // any flag accepted by clang-cl.
7341
7342 // These are spelled the same way in clang and cl.exe,.
7343 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7344 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007345
7346 // Optimization level.
7347 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7348 if (A->getOption().getID() == options::OPT_O0) {
7349 CmdArgs.push_back("/Od");
7350 } else {
7351 StringRef OptLevel = A->getValue();
7352 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7353 A->render(Args, CmdArgs);
7354 else if (OptLevel == "3")
7355 CmdArgs.push_back("/Ox");
7356 }
7357 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007358
7359 // Flags for which clang-cl have an alias.
7360 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7361
7362 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7363 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7364 : "/GR-");
7365 if (Args.hasArg(options::OPT_fsyntax_only))
7366 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007367 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7368 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007369
Hans Wennborg260ff402013-09-27 17:54:18 +00007370 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7371 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7372 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7373
Hans Wennborg87cfa712013-09-19 20:32:16 +00007374 // Flags that can simply be passed through.
7375 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7376 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7377
7378 // The order of these flags is relevant, so pick the last one.
7379 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7380 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7381 A->render(Args, CmdArgs);
7382
7383
7384 // Input filename.
7385 assert(Inputs.size() == 1);
7386 const InputInfo &II = Inputs[0];
7387 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7388 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7389 if (II.isFilename())
7390 CmdArgs.push_back(II.getFilename());
7391 else
7392 II.getInputArg().renderAsInput(Args, CmdArgs);
7393
7394 // Output filename.
7395 assert(Output.getType() == types::TY_Object);
7396 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7397 Output.getFilename());
7398 CmdArgs.push_back(Fo);
7399
Hans Wennborg188382e2013-09-20 18:16:35 +00007400 const Driver &D = getToolChain().getDriver();
7401 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg87cfa712013-09-19 20:32:16 +00007402
Hans Wennborg188382e2013-09-20 18:16:35 +00007403 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007404}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007405
7406
7407/// XCore Tools
7408// We pass assemble and link construction to the xcc tool.
7409
7410void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7411 const InputInfo &Output,
7412 const InputInfoList &Inputs,
7413 const ArgList &Args,
7414 const char *LinkingOutput) const {
7415 ArgStringList CmdArgs;
7416
7417 CmdArgs.push_back("-o");
7418 CmdArgs.push_back(Output.getFilename());
7419
7420 CmdArgs.push_back("-c");
7421
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007422 if (Args.hasArg(options::OPT_v))
7423 CmdArgs.push_back("-v");
7424
7425 if (Args.hasArg(options::OPT_g_Group))
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007426 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007427
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007428 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7429 false))
7430 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007431
7432 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7433 options::OPT_Xassembler);
7434
7435 for (InputInfoList::const_iterator
7436 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7437 const InputInfo &II = *it;
7438 CmdArgs.push_back(II.getFilename());
7439 }
7440
7441 const char *Exec =
7442 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7443 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7444}
7445
7446void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7447 const InputInfo &Output,
7448 const InputInfoList &Inputs,
7449 const ArgList &Args,
7450 const char *LinkingOutput) const {
7451 ArgStringList CmdArgs;
7452
7453 if (Output.isFilename()) {
7454 CmdArgs.push_back("-o");
7455 CmdArgs.push_back(Output.getFilename());
7456 } else {
7457 assert(Output.isNothing() && "Invalid output.");
7458 }
7459
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007460 if (Args.hasArg(options::OPT_v))
7461 CmdArgs.push_back("-v");
7462
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007463 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7464 if (EH.ShouldUseExceptionTables)
7465 CmdArgs.push_back("-fexceptions");
7466
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007467 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7468
7469 const char *Exec =
7470 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7471 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7472}