blob: 3106e1506ba2b0b1eaa0eb3a0df4dc8412fdd812 [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 Abdulrasool377066a2014-03-27 22:50:18 +0000684 if (Triple.getOS() != llvm::Triple::UnknownOS ||
685 !Triple.isOSBinFormatMachO())
686 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000687 break;
688 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000689 }
690 }
691
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000692 return FloatABI;
693}
694
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000695static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
696 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000697 std::vector<const char *> &Features,
698 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000699 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000700 if (!ForAS) {
701 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
702 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
703 // stripped out by the ARM target. We should probably pass this a new
704 // -target-option, which is handled by the -cc1/-cc1as invocation.
705 //
706 // FIXME2: For consistency, it would be ideal if we set up the target
707 // machine state the same when using the frontend or the assembler. We don't
708 // currently do that for the assembler, we pass the options directly to the
709 // backend and never even instantiate the frontend TargetInfo. If we did,
710 // and used its handleTargetFeatures hook, then we could ensure the
711 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000712
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000713 // Use software floating point operations?
714 if (FloatABI == "soft")
715 Features.push_back("+soft-float");
716
717 // Use software floating point argument passing?
718 if (FloatABI != "hard")
719 Features.push_back("+soft-float-abi");
720 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000721
722 // Honor -mfpu=.
723 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000724 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000725 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
726 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000727
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000728 // Setting -msoft-float effectively disables NEON because of the GCC
729 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000730 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000731 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000732 // Also need to explicitly disable features which imply NEON.
733 Features.push_back("-crypto");
734 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000735
736 // En/disable crc
737 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
738 options::OPT_mnocrc)) {
739 if (A->getOption().matches(options::OPT_mcrc))
740 Features.push_back("+crc");
741 else
742 Features.push_back("-crc");
743 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000744}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000745
746void Clang::AddARMTargetArgs(const ArgList &Args,
747 ArgStringList &CmdArgs,
748 bool KernelOrKext) const {
749 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000750 // Get the effective triple, which takes into account the deployment target.
751 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
752 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000753 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000754
755 // Select the ABI to use.
756 //
757 // FIXME: Support -meabi.
758 const char *ABIName = 0;
759 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000760 ABIName = A->getValue();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000761 } else if (Triple.isOSDarwin()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000762 // The backend is hardwired to assume AAPCS for M-class processors, ensure
763 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000764 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000765 (Triple.getOS() == llvm::Triple::UnknownOS &&
766 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000767 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000768 ABIName = "aapcs";
769 } else {
770 ABIName = "apcs-gnu";
771 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000772 } else {
773 // Select the default based on the platform.
774 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000775 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000776 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000777 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000778 ABIName = "aapcs-linux";
779 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000780 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000781 case llvm::Triple::EABI:
782 ABIName = "aapcs";
783 break;
784 default:
785 ABIName = "apcs-gnu";
786 }
787 }
788 CmdArgs.push_back("-target-abi");
789 CmdArgs.push_back(ABIName);
790
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000791 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000792 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000793 if (FloatABI == "soft") {
794 // Floating point operations and argument passing are soft.
795 //
796 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000797 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000798 CmdArgs.push_back("-mfloat-abi");
799 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000800 } else if (FloatABI == "softfp") {
801 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000802 CmdArgs.push_back("-mfloat-abi");
803 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000804 } else {
805 // Floating point operations and argument passing are hard.
806 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000807 CmdArgs.push_back("-mfloat-abi");
808 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000809 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000810
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000811 // Kernel code has more strict alignment requirements.
812 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000813 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000814 CmdArgs.push_back("-backend-option");
815 CmdArgs.push_back("-arm-long-calls");
816 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000817
Daniel Dunbar12100e22011-03-22 16:48:17 +0000818 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000819 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000820
821 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000822 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000823 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000824 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000825
826 // Setting -mno-global-merge disables the codegen global merge pass. Setting
827 // -mglobal-merge has no effect as the pass is enabled by default.
828 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
829 options::OPT_mno_global_merge)) {
830 if (A->getOption().matches(options::OPT_mno_global_merge))
831 CmdArgs.push_back("-mno-global-merge");
832 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000833
Bob Wilson9c8af452013-04-11 18:53:25 +0000834 if (!Args.hasFlag(options::OPT_mimplicit_float,
835 options::OPT_mno_implicit_float,
836 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000837 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000838
839 // llvm does not support reserving registers in general. There is support
840 // for reserving r9 on ARM though (defined as a platform-specific register
841 // in ARM EABI).
842 if (Args.hasArg(options::OPT_ffixed_r9)) {
843 CmdArgs.push_back("-backend-option");
844 CmdArgs.push_back("-arm-reserve-r9");
845 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000846}
847
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000848// Get CPU and ABI names. They are not independent
849// so we have to calculate them together.
850static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000851 const llvm::Triple &Triple,
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000852 StringRef &CPUName,
853 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000854 const char *DefMips32CPU = "mips32r2";
855 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000856
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000857 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000858 options::OPT_mcpu_EQ))
859 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000860
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000861 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000862 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000863 // Convert a GNU style Mips ABI name to the name
864 // accepted by LLVM Mips backend.
865 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
866 .Case("32", "o32")
867 .Case("64", "n64")
868 .Default(ABIName);
869 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000870
871 // Setup default CPU and ABI names.
872 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000873 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000874 default:
875 llvm_unreachable("Unexpected triple arch name");
876 case llvm::Triple::mips:
877 case llvm::Triple::mipsel:
878 CPUName = DefMips32CPU;
879 break;
880 case llvm::Triple::mips64:
881 case llvm::Triple::mips64el:
882 CPUName = DefMips64CPU;
883 break;
884 }
885 }
886
887 if (!ABIName.empty()) {
888 // Deduce CPU name from ABI name.
889 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000890 .Cases("32", "o32", "eabi", DefMips32CPU)
891 .Cases("n32", "n64", "64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000892 .Default("");
893 }
894 else if (!CPUName.empty()) {
895 // Deduce ABI name from CPU name.
896 ABIName = llvm::StringSwitch<const char *>(CPUName)
897 .Cases("mips32", "mips32r2", "o32")
898 .Cases("mips64", "mips64r2", "n64")
899 .Default("");
900 }
901
902 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000903}
904
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000905// Convert ABI name to the GNU tools acceptable variant.
906static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
907 return llvm::StringSwitch<llvm::StringRef>(ABI)
908 .Case("o32", "32")
909 .Case("n64", "64")
910 .Default(ABI);
911}
912
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000913// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
914// and -mfloat-abi=.
915static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000916 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000917 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000918 options::OPT_mhard_float,
919 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000920 if (A->getOption().matches(options::OPT_msoft_float))
921 FloatABI = "soft";
922 else if (A->getOption().matches(options::OPT_mhard_float))
923 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000924 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000925 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000926 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000927 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000928 FloatABI = "hard";
929 }
930 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000931 }
932
933 // If unspecified, choose the default based on the platform.
934 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000935 // Assume "hard", because it's a default value used by gcc.
936 // When we start to recognize specific target MIPS processors,
937 // we will be able to select the default more correctly.
938 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000939 }
940
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000941 return FloatABI;
942}
943
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000944static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000945 std::vector<const char *> &Features,
946 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000947 StringRef FeatureName) {
948 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000949 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000950 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000951 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000952 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000953 }
954}
955
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000956static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
957 std::vector<const char *> &Features) {
958 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +0000959 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000960 // FIXME: Note, this is a hack. We need to pass the selected float
961 // mode to the MipsTargetInfoBase to define appropriate macros there.
962 // Now it is the only method.
963 Features.push_back("+soft-float");
964 }
965
Simon Atanasyan22127ce2013-09-24 09:09:16 +0000966 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
967 if (StringRef(A->getValue()) == "2008")
968 Features.push_back("+nan2008");
969 }
970
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000971 AddTargetFeature(Args, Features, options::OPT_msingle_float,
972 options::OPT_mdouble_float, "single-float");
973 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
974 "mips16");
975 AddTargetFeature(Args, Features, options::OPT_mmicromips,
976 options::OPT_mno_micromips, "micromips");
977 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
978 "dsp");
979 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
980 "dspr2");
981 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
982 "msa");
Daniel Sanders94694172013-10-17 14:55:58 +0000983 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
984 "fp64");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000985}
986
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000987void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +0000988 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000989 const Driver &D = getToolChain().getDriver();
990 StringRef CPUName;
991 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000992 const llvm::Triple &Triple = getToolChain().getTriple();
993 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000994
995 CmdArgs.push_back("-target-abi");
996 CmdArgs.push_back(ABIName.data());
997
998 StringRef FloatABI = getMipsFloatABI(D, Args);
999
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001000 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001001 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001002 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001003 CmdArgs.push_back("-mfloat-abi");
1004 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001005 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001006 else {
1007 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001008 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001009 CmdArgs.push_back("-mfloat-abi");
1010 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001011 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001012
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001013 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1014 if (A->getOption().matches(options::OPT_mxgot)) {
1015 CmdArgs.push_back("-mllvm");
1016 CmdArgs.push_back("-mxgot");
1017 }
1018 }
1019
Simon Atanasyanc580b322013-05-11 06:33:44 +00001020 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1021 options::OPT_mno_ldc1_sdc1)) {
1022 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1023 CmdArgs.push_back("-mllvm");
1024 CmdArgs.push_back("-mno-ldc1-sdc1");
1025 }
1026 }
1027
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001028 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1029 options::OPT_mno_check_zero_division)) {
1030 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1031 CmdArgs.push_back("-mllvm");
1032 CmdArgs.push_back("-mno-check-zero-division");
1033 }
1034 }
1035
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001036 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001037 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001038 CmdArgs.push_back("-mllvm");
1039 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1040 A->claim();
1041 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001042}
1043
Hal Finkel8eb59282012-06-11 22:35:19 +00001044/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1045static std::string getPPCTargetCPU(const ArgList &Args) {
1046 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001047 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001048
1049 if (CPUName == "native") {
1050 std::string CPU = llvm::sys::getHostCPUName();
1051 if (!CPU.empty() && CPU != "generic")
1052 return CPU;
1053 else
1054 return "";
1055 }
1056
1057 return llvm::StringSwitch<const char *>(CPUName)
1058 .Case("common", "generic")
1059 .Case("440", "440")
1060 .Case("440fp", "440")
1061 .Case("450", "450")
1062 .Case("601", "601")
1063 .Case("602", "602")
1064 .Case("603", "603")
1065 .Case("603e", "603e")
1066 .Case("603ev", "603ev")
1067 .Case("604", "604")
1068 .Case("604e", "604e")
1069 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001070 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001071 .Case("G3", "g3")
1072 .Case("7400", "7400")
1073 .Case("G4", "g4")
1074 .Case("7450", "7450")
1075 .Case("G4+", "g4+")
1076 .Case("750", "750")
1077 .Case("970", "970")
1078 .Case("G5", "g5")
1079 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001080 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001081 .Case("e500mc", "e500mc")
1082 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001083 .Case("power3", "pwr3")
1084 .Case("power4", "pwr4")
1085 .Case("power5", "pwr5")
1086 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001087 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001088 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001089 .Case("power7", "pwr7")
Bill Schmidt38378a02013-02-01 20:23:10 +00001090 .Case("pwr3", "pwr3")
1091 .Case("pwr4", "pwr4")
1092 .Case("pwr5", "pwr5")
1093 .Case("pwr5x", "pwr5x")
1094 .Case("pwr6", "pwr6")
1095 .Case("pwr6x", "pwr6x")
1096 .Case("pwr7", "pwr7")
Hal Finkel8eb59282012-06-11 22:35:19 +00001097 .Case("powerpc", "ppc")
1098 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001099 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001100 .Default("");
1101 }
1102
1103 return "";
1104}
1105
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001106static void getPPCTargetFeatures(const ArgList &Args,
1107 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001108 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1109 ie = Args.filtered_end();
1110 it != ie; ++it) {
1111 StringRef Name = (*it)->getOption().getName();
1112 (*it)->claim();
1113
1114 // Skip over "-m".
1115 assert(Name.startswith("m") && "Invalid feature name.");
1116 Name = Name.substr(1);
1117
1118 bool IsNegative = Name.startswith("no-");
1119 if (IsNegative)
1120 Name = Name.substr(3);
1121
1122 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1123 // pass the correct option to the backend while calling the frontend
1124 // option the same.
1125 // TODO: Change the LLVM backend option maybe?
1126 if (Name == "mfcrf")
1127 Name = "mfocrf";
1128
1129 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1130 }
1131
1132 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001133 AddTargetFeature(Args, Features, options::OPT_faltivec,
1134 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001135}
1136
Tom Stellard6674c702013-04-01 20:56:53 +00001137/// Get the (LLVM) name of the R600 gpu we are targeting.
1138static std::string getR600TargetGPU(const ArgList &Args) {
1139 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001140 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001141 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001142 .Cases("rv630", "rv635", "r600")
1143 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001144 .Case("rv740", "rv770")
1145 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001146 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001147 .Case("hemlock", "cypress")
1148 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001149 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001150 }
1151 return "";
1152}
1153
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001154static void getSparcTargetFeatures(const ArgList &Args,
1155 std::vector<const char *> Features) {
1156 bool SoftFloatABI = true;
1157 if (Arg *A =
1158 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1159 if (A->getOption().matches(options::OPT_mhard_float))
1160 SoftFloatABI = false;
1161 }
1162 if (SoftFloatABI)
1163 Features.push_back("+soft-float");
1164}
1165
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001166void Clang::AddSparcTargetArgs(const ArgList &Args,
1167 ArgStringList &CmdArgs) const {
1168 const Driver &D = getToolChain().getDriver();
1169
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001170 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001171 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001172 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1173 options::OPT_mhard_float)) {
1174 if (A->getOption().matches(options::OPT_msoft_float))
1175 FloatABI = "soft";
1176 else if (A->getOption().matches(options::OPT_mhard_float))
1177 FloatABI = "hard";
1178 }
1179
1180 // If unspecified, choose the default based on the platform.
1181 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001182 // Assume "soft", but warn the user we are guessing.
1183 FloatABI = "soft";
1184 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001185 }
1186
1187 if (FloatABI == "soft") {
1188 // Floating point operations and argument passing are soft.
1189 //
1190 // FIXME: This changes CPP defines, we need -target-soft-float.
1191 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001192 } else {
1193 assert(FloatABI == "hard" && "Invalid float abi!");
1194 CmdArgs.push_back("-mhard-float");
1195 }
1196}
1197
Richard Sandiford4652d892013-07-19 16:51:51 +00001198static const char *getSystemZTargetCPU(const ArgList &Args) {
1199 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1200 return A->getValue();
1201 return "z10";
1202}
1203
Chandler Carruth953fb082013-01-13 11:46:33 +00001204static const char *getX86TargetCPU(const ArgList &Args,
1205 const llvm::Triple &Triple) {
1206 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001207 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001208 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001209 return "core-avx2";
1210
Chandler Carruth953fb082013-01-13 11:46:33 +00001211 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001212 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001213
1214 // FIXME: Reject attempts to use -march=native unless the target matches
1215 // the host.
1216 //
1217 // FIXME: We should also incorporate the detected target features for use
1218 // with -native.
1219 std::string CPU = llvm::sys::getHostCPUName();
1220 if (!CPU.empty() && CPU != "generic")
1221 return Args.MakeArgString(CPU);
1222 }
1223
1224 // Select the default CPU if none was given (or detection failed).
1225
1226 if (Triple.getArch() != llvm::Triple::x86_64 &&
1227 Triple.getArch() != llvm::Triple::x86)
1228 return 0; // This routine is only handling x86 targets.
1229
1230 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1231
1232 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001233 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001234 if (Triple.getArchName() == "x86_64h")
1235 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001236 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001237 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001238
Alexey Bataev286d1b92014-01-31 04:07:13 +00001239 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001240 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001241 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001242
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001243 // Everything else goes to x86-64 in 64-bit mode.
1244 if (Is64Bit)
1245 return "x86-64";
1246
1247 switch (Triple.getOS()) {
1248 case llvm::Triple::FreeBSD:
1249 case llvm::Triple::NetBSD:
1250 case llvm::Triple::OpenBSD:
1251 return "i486";
1252 case llvm::Triple::Haiku:
1253 return "i586";
1254 case llvm::Triple::Bitrig:
1255 return "i686";
1256 default:
1257 // Fallback to p4.
1258 return "pentium4";
1259 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001260}
1261
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001262static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1263 switch(T.getArch()) {
1264 default:
1265 return "";
1266
Amara Emerson703da2e2013-10-31 09:32:33 +00001267 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001268 case llvm::Triple::aarch64_be:
Amara Emerson703da2e2013-10-31 09:32:33 +00001269 return getAArch64TargetCPU(Args, T);
1270
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001271 case llvm::Triple::arm:
1272 case llvm::Triple::thumb:
Bernard Ogden31561762013-12-12 13:27:11 +00001273 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001274
1275 case llvm::Triple::mips:
1276 case llvm::Triple::mipsel:
1277 case llvm::Triple::mips64:
1278 case llvm::Triple::mips64el: {
1279 StringRef CPUName;
1280 StringRef ABIName;
1281 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1282 return CPUName;
1283 }
1284
1285 case llvm::Triple::ppc:
1286 case llvm::Triple::ppc64:
1287 case llvm::Triple::ppc64le: {
1288 std::string TargetCPUName = getPPCTargetCPU(Args);
1289 // LLVM may default to generating code for the native CPU,
1290 // but, like gcc, we default to a more generic option for
1291 // each architecture. (except on Darwin)
1292 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1293 if (T.getArch() == llvm::Triple::ppc64)
1294 TargetCPUName = "ppc64";
1295 else if (T.getArch() == llvm::Triple::ppc64le)
1296 TargetCPUName = "ppc64le";
1297 else
1298 TargetCPUName = "ppc";
1299 }
1300 return TargetCPUName;
1301 }
1302
1303 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001304 case llvm::Triple::sparcv9:
1305 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001306 return A->getValue();
1307 return "";
1308
1309 case llvm::Triple::x86:
1310 case llvm::Triple::x86_64:
1311 return getX86TargetCPU(Args, T);
1312
1313 case llvm::Triple::hexagon:
1314 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1315
1316 case llvm::Triple::systemz:
1317 return getSystemZTargetCPU(Args);
1318
1319 case llvm::Triple::r600:
1320 return getR600TargetGPU(Args);
1321 }
1322}
1323
Alp Tokerce365ca2013-12-02 12:43:03 +00001324static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1325 ArgStringList &CmdArgs) {
1326 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1327 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1328 // forward.
1329 CmdArgs.push_back("-plugin");
1330 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1331 CmdArgs.push_back(Args.MakeArgString(Plugin));
1332
1333 // Try to pass driver level flags relevant to LTO code generation down to
1334 // the plugin.
1335
1336 // Handle flags for selecting CPU variants.
1337 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1338 if (!CPU.empty())
1339 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1340}
1341
Jim Grosbach82eee262013-11-16 00:53:35 +00001342static void getX86TargetFeatures(const llvm::Triple &Triple,
1343 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001344 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001345 if (Triple.getArchName() == "x86_64h") {
1346 // x86_64h implies quite a few of the more modern subtarget features
1347 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1348 Features.push_back("-rdrnd");
1349 Features.push_back("-aes");
1350 Features.push_back("-pclmul");
1351 Features.push_back("-rtm");
1352 Features.push_back("-hle");
1353 Features.push_back("-fsgsbase");
1354 }
1355
Alexey Bataev286d1b92014-01-31 04:07:13 +00001356 if (Triple.getEnvironment() == llvm::Triple::Android) {
1357 // Add sse3 feature to comply with gcc on Android
1358 Features.push_back("+sse3");
1359 }
1360
Jim Grosbach82eee262013-11-16 00:53:35 +00001361 // Now add any that the user explicitly requested on the command line,
1362 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001363 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1364 ie = Args.filtered_end();
1365 it != ie; ++it) {
1366 StringRef Name = (*it)->getOption().getName();
1367 (*it)->claim();
1368
1369 // Skip over "-m".
1370 assert(Name.startswith("m") && "Invalid feature name.");
1371 Name = Name.substr(1);
1372
1373 bool IsNegative = Name.startswith("no-");
1374 if (IsNegative)
1375 Name = Name.substr(3);
1376
1377 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1378 }
1379}
1380
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001381void Clang::AddX86TargetArgs(const ArgList &Args,
1382 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001383 if (!Args.hasFlag(options::OPT_mred_zone,
1384 options::OPT_mno_red_zone,
1385 true) ||
1386 Args.hasArg(options::OPT_mkernel) ||
1387 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001388 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001389
Bob Wilson2616e2e2013-02-10 16:01:41 +00001390 // Default to avoid implicit floating-point for kernel/kext code, but allow
1391 // that to be overridden with -mno-soft-float.
1392 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1393 Args.hasArg(options::OPT_fapple_kext));
1394 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1395 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001396 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001397 options::OPT_mno_implicit_float)) {
1398 const Option &O = A->getOption();
1399 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1400 O.matches(options::OPT_msoft_float));
1401 }
1402 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001403 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001404}
1405
Matthew Curtise8f80a12012-12-06 17:49:03 +00001406static inline bool HasPICArg(const ArgList &Args) {
1407 return Args.hasArg(options::OPT_fPIC)
1408 || Args.hasArg(options::OPT_fpic);
1409}
1410
1411static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1412 return Args.getLastArg(options::OPT_G,
1413 options::OPT_G_EQ,
1414 options::OPT_msmall_data_threshold_EQ);
1415}
1416
1417static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1418 std::string value;
1419 if (HasPICArg(Args))
1420 value = "0";
1421 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1422 value = A->getValue();
1423 A->claim();
1424 }
1425 return value;
1426}
1427
Tony Linthicum76329bf2011-12-12 21:14:55 +00001428void Clang::AddHexagonTargetArgs(const ArgList &Args,
1429 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001430 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001431 CmdArgs.push_back("-mqdsp6-compat");
1432 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001433
Matthew Curtise8f80a12012-12-06 17:49:03 +00001434 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1435 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001436 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001437 CmdArgs.push_back(Args.MakeArgString(
1438 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001439 }
1440
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001441 if (!Args.hasArg(options::OPT_fno_short_enums))
1442 CmdArgs.push_back("-fshort-enums");
1443 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1444 CmdArgs.push_back ("-mllvm");
1445 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1446 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001447 CmdArgs.push_back ("-mllvm");
1448 CmdArgs.push_back ("-machine-sink-split=0");
1449}
1450
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001451static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1452 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001453 // Honor -mfpu=.
1454 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001455 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001456 else
1457 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001458
1459 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1460 Features.push_back("-fp-armv8");
1461 Features.push_back("-crypto");
1462 Features.push_back("-neon");
1463 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001464}
1465
1466static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001467 const ArgList &Args, ArgStringList &CmdArgs,
1468 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001469 std::vector<const char *> Features;
1470 switch (Triple.getArch()) {
1471 default:
1472 break;
1473 case llvm::Triple::mips:
1474 case llvm::Triple::mipsel:
1475 case llvm::Triple::mips64:
1476 case llvm::Triple::mips64el:
1477 getMIPSTargetFeatures(D, Args, Features);
1478 break;
1479
1480 case llvm::Triple::arm:
1481 case llvm::Triple::thumb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001482 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001483 break;
1484
1485 case llvm::Triple::ppc:
1486 case llvm::Triple::ppc64:
1487 case llvm::Triple::ppc64le:
1488 getPPCTargetFeatures(Args, Features);
1489 break;
1490 case llvm::Triple::sparc:
1491 getSparcTargetFeatures(Args, Features);
1492 break;
1493 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001494 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001495 getAArch64TargetFeatures(D, Args, Features);
1496 break;
1497 case llvm::Triple::x86:
1498 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001499 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001500 break;
1501 }
Rafael Espindola43964802013-08-21 17:34:32 +00001502
1503 // Find the last of each feature.
1504 llvm::StringMap<unsigned> LastOpt;
1505 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1506 const char *Name = Features[I];
1507 assert(Name[0] == '-' || Name[0] == '+');
1508 LastOpt[Name + 1] = I;
1509 }
1510
1511 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1512 // If this feature was overridden, ignore it.
1513 const char *Name = Features[I];
1514 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1515 assert(LastI != LastOpt.end());
1516 unsigned Last = LastI->second;
1517 if (Last != I)
1518 continue;
1519
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001520 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001521 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001522 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001523}
1524
Eric Christopher84fbdb42011-08-19 00:30:14 +00001525static bool
John McCall5fb5df92012-06-20 06:18:46 +00001526shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001527 const llvm::Triple &Triple) {
1528 // We use the zero-cost exception tables for Objective-C if the non-fragile
1529 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1530 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001531 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001532 return true;
1533
Bob Wilson83e723a2013-12-05 19:38:42 +00001534 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001535 return false;
1536
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001537 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001538 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001539 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001540}
1541
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001542namespace {
1543 struct ExceptionSettings {
1544 bool ExceptionsEnabled;
1545 bool ShouldUseExceptionTables;
1546 ExceptionSettings() : ExceptionsEnabled(false),
1547 ShouldUseExceptionTables(false) {}
1548 };
1549} // end anonymous namespace.
1550
Robert Lytton694f8842014-02-13 10:38:56 +00001551// exceptionSettings() exists to share the logic between -cc1 and linker invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001552static ExceptionSettings exceptionSettings(const ArgList &Args,
1553 const llvm::Triple &Triple) {
1554 ExceptionSettings ES;
1555
1556 // Are exceptions enabled by default?
1557 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1558
1559 // This keeps track of whether exceptions were explicitly turned on or off.
1560 bool DidHaveExplicitExceptionFlag = false;
1561
1562 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1563 options::OPT_fno_exceptions)) {
1564 if (A->getOption().matches(options::OPT_fexceptions))
1565 ES.ExceptionsEnabled = true;
1566 else
1567 ES.ExceptionsEnabled = false;
1568
1569 DidHaveExplicitExceptionFlag = true;
1570 }
1571
1572 // Exception tables and cleanups can be enabled with -fexceptions even if the
1573 // language itself doesn't support exceptions.
1574 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1575 ES.ShouldUseExceptionTables = true;
1576
1577 return ES;
1578}
1579
Anders Carlssone96ab552011-02-28 02:27:16 +00001580/// addExceptionArgs - Adds exception related arguments to the driver command
1581/// arguments. There's a master flag, -fexceptions and also language specific
1582/// flags to enable/disable C++ and Objective-C exceptions.
1583/// This makes it possible to for example disable C++ exceptions but enable
1584/// Objective-C exceptions.
1585static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1586 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001587 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001588 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001589 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001590 if (KernelOrKext) {
1591 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1592 // arguments now to avoid warnings about unused arguments.
1593 Args.ClaimAllArgs(options::OPT_fexceptions);
1594 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1595 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1596 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1597 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1598 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001599 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001600 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001601
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001602 // Gather the exception settings from the command line arguments.
1603 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001604
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001605 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1606 // is not necessarily sensible, but follows GCC.
1607 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001608 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001609 options::OPT_fno_objc_exceptions,
1610 true)) {
1611 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001612
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001613 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001614 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001615 }
1616
1617 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001618 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001619
Eric Christopher84fbdb42011-08-19 00:30:14 +00001620 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1621 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001622 options::OPT_fexceptions,
1623 options::OPT_fno_exceptions)) {
1624 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1625 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001626 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001627 CXXExceptionsEnabled = false;
1628 }
1629
1630 if (CXXExceptionsEnabled) {
1631 CmdArgs.push_back("-fcxx-exceptions");
1632
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001633 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001634 }
1635 }
1636
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001637 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001638 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001639}
1640
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001641static bool ShouldDisableAutolink(const ArgList &Args,
1642 const ToolChain &TC) {
1643 bool Default = true;
1644 if (TC.getTriple().isOSDarwin()) {
1645 // The native darwin assembler doesn't support the linker_option directives,
1646 // so we disable them if we think the .s file will be passed to it.
1647 Default = TC.useIntegratedAs();
1648 }
1649 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1650 Default);
1651}
1652
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001653static bool ShouldDisableCFI(const ArgList &Args,
1654 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001655 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001656 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001657 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001658 // we disable them if we think the .s file will be passed to it.
Rafael Espindola84b588b2013-03-18 18:10:27 +00001659 Default = TC.useIntegratedAs();
Rafael Espindolaf934f982011-05-17 16:26:17 +00001660 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001661 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
Eric Christopher45f2e712012-12-18 00:31:10 +00001662 options::OPT_fno_dwarf2_cfi_asm,
1663 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001664}
1665
Ted Kremenek62093662013-03-12 17:02:12 +00001666static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1667 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001668 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1669 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001670 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001671 return !UseDwarfDirectory;
1672}
1673
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001674/// \brief Check whether the given input tree contains any compilation actions.
1675static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001676 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001677 return true;
1678
1679 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1680 if (ContainsCompileAction(*it))
1681 return true;
1682
1683 return false;
1684}
1685
1686/// \brief Check if -relax-all should be passed to the internal assembler.
1687/// This is done by default when compiling non-assembler source with -O0.
1688static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1689 bool RelaxDefault = true;
1690
1691 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1692 RelaxDefault = A->getOption().matches(options::OPT_O0);
1693
1694 if (RelaxDefault) {
1695 RelaxDefault = false;
1696 for (ActionList::const_iterator it = C.getActions().begin(),
1697 ie = C.getActions().end(); it != ie; ++it) {
1698 if (ContainsCompileAction(*it)) {
1699 RelaxDefault = true;
1700 break;
1701 }
1702 }
1703 }
1704
1705 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1706 RelaxDefault);
1707}
1708
David Blaikie9260ed62013-07-25 21:19:01 +00001709static void CollectArgsForIntegratedAssembler(Compilation &C,
1710 const ArgList &Args,
1711 ArgStringList &CmdArgs,
1712 const Driver &D) {
1713 if (UseRelaxAll(C, Args))
1714 CmdArgs.push_back("-mrelax-all");
1715
David Peixottodfb66142013-11-14 22:52:58 +00001716 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001717 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001718 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1719 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1720 // arg after parsing the '-I' arg.
1721 bool TakeNextArg = false;
1722
David Blaikie9260ed62013-07-25 21:19:01 +00001723 // When using an integrated assembler, translate -Wa, and -Xassembler
1724 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001725 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001726 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1727 options::OPT_Xassembler),
1728 ie = Args.filtered_end(); it != ie; ++it) {
1729 const Arg *A = *it;
1730 A->claim();
1731
1732 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1733 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001734 if (TakeNextArg) {
1735 CmdArgs.push_back(Value.data());
1736 TakeNextArg = false;
1737 continue;
1738 }
David Blaikie9260ed62013-07-25 21:19:01 +00001739
1740 if (Value == "-force_cpusubtype_ALL") {
1741 // Do nothing, this is the default and we don't support anything else.
1742 } else if (Value == "-L") {
1743 CmdArgs.push_back("-msave-temp-labels");
1744 } else if (Value == "--fatal-warnings") {
1745 CmdArgs.push_back("-mllvm");
1746 CmdArgs.push_back("-fatal-assembler-warnings");
1747 } else if (Value == "--noexecstack") {
1748 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001749 } else if (Value == "-compress-debug-sections" ||
1750 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001751 CompressDebugSections = true;
1752 } else if (Value == "-nocompress-debug-sections" ||
1753 Value == "--nocompress-debug-sections") {
1754 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001755 } else if (Value.startswith("-I")) {
1756 CmdArgs.push_back(Value.data());
1757 // We need to consume the next argument if the current arg is a plain
1758 // -I. The next arg will be the include directory.
1759 if (Value == "-I")
1760 TakeNextArg = true;
David Blaikie9260ed62013-07-25 21:19:01 +00001761 } else {
1762 D.Diag(diag::err_drv_unsupported_option_argument)
1763 << A->getOption().getName() << Value;
1764 }
1765 }
1766 }
David Blaikie7e2fd942014-03-27 20:47:30 +00001767 if (CompressDebugSections)
1768 CmdArgs.push_back("-compress-debug-sections");
David Blaikie9260ed62013-07-25 21:19:01 +00001769}
1770
Renato Goline807c122014-01-31 11:47:28 +00001771// Until ARM libraries are build separately, we have them all in one library
1772static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
1773 if (TC.getArch() == llvm::Triple::arm)
1774 return "arm";
1775 else
1776 return TC.getArchName();
1777}
1778
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001779static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1780 // The runtimes are located in the OS-specific resource directory.
1781 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001782 const llvm::Triple &Triple = TC.getTriple();
1783 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1784 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1785 "freebsd" : TC.getOS();
1786 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001787 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001788}
1789
Renato Golinc4b49242014-02-13 10:01:16 +00001790// This adds the static libclang_rt.arch.a directly to the command line
1791// FIXME: Make sure we can also emit shared objects if they're requested
1792// and available, check for possible errors, etc.
1793static void addClangRTLinux(
1794 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001795 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
1796 llvm::sys::path::append(LibClangRT,
Renato Golinc4b49242014-02-13 10:01:16 +00001797 Twine("libclang_rt.") + getArchNameForCompilerRTLib(TC) + ".a");
1798
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001799 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001800 CmdArgs.push_back("-lgcc_s");
1801 if (TC.getDriver().CCCIsCXX())
1802 CmdArgs.push_back("-lgcc_eh");
1803}
1804
Alexey Samsonov7811d192014-02-20 13:57:37 +00001805static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001806 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1807 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1808 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001809 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001810 Args.hasArg(options::OPT_fcreate_profile) ||
1811 Args.hasArg(options::OPT_coverage)))
1812 return;
1813
Duncan P. N. Exon Smitha19ffae2014-03-27 16:20:02 +00001814 // Pull in runtime for -fprofile-inst-generate. This is required since there
1815 // are no calls to the runtime in the code.
1816 if (Args.hasArg(options::OPT_fprofile_instr_generate)) {
1817 CmdArgs.push_back("-u");
1818 CmdArgs.push_back("___llvm_profile_runtime");
1819 }
1820
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001821 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1822 llvm::sys::path::append(LibProfile,
Renato Goline807c122014-01-31 11:47:28 +00001823 Twine("libclang_rt.profile-") + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001824
1825 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1826}
1827
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001828static void addSanitizerRTLinkFlags(
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001829 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
Richard Smithf3e624c2013-03-23 00:30:08 +00001830 const StringRef Sanitizer, bool BeforeLibStdCXX,
1831 bool ExportSymbols = true) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001832 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1833 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1834 llvm::sys::path::append(LibSanitizer,
1835 (Twine("libclang_rt.") + Sanitizer + "-" +
1836 getArchNameForCompilerRTLib(TC) + ".a"));
Richard Smithcff3cde2013-03-20 23:49:07 +00001837
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001838 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1839 // etc.) so that the linker picks custom versions of the global 'operator
1840 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001841 // strategy of inserting it at the front of the link command. It also
1842 // needs to be forced to end up in the executable, so wrap it in
1843 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001844 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001845 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001846 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001847 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001848
1849 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1850 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1851
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001852 CmdArgs.push_back("-lpthread");
Evgeniy Stepanov758b5072013-05-24 14:28:03 +00001853 CmdArgs.push_back("-lrt");
Evgeniy Stepanov4ae68462013-10-29 19:48:47 +00001854 CmdArgs.push_back("-lm");
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001855 // There's no libdl on FreeBSD.
1856 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1857 CmdArgs.push_back("-ldl");
Richard Smithf3e624c2013-03-23 00:30:08 +00001858
1859 // If possible, use a dynamic symbols file to export the symbols from the
1860 // runtime library. If we can't do so, use -export-dynamic instead to export
1861 // all symbols from the binary.
1862 if (ExportSymbols) {
1863 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1864 CmdArgs.push_back(
1865 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1866 else
1867 CmdArgs.push_back("-export-dynamic");
1868 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001869}
1870
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001871/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1872/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001873static void addAsanRT(const ToolChain &TC, const ArgList &Args,
1874 ArgStringList &CmdArgs) {
Nick Lewycky609dd662013-10-11 03:33:53 +00001875 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001876 SmallString<128> LibAsan = getCompilerRTLibDir(TC);
1877 llvm::sys::path::append(LibAsan,
1878 (Twine("libclang_rt.asan-") +
1879 getArchNameForCompilerRTLib(TC) + "-android.so"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001880 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001881 } else {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001882 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001883 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001884 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001885}
1886
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001887/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1888/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001889static void addTsanRT(const ToolChain &TC, const ArgList &Args,
1890 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001891 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001892 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001893}
1894
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001895/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1896/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001897static void addMsanRT(const ToolChain &TC, const ArgList &Args,
1898 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001899 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001900 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001901}
1902
1903/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1904/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001905static void addLsanRT(const ToolChain &TC, const ArgList &Args,
1906 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001907 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001908 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001909}
1910
Richard Smithe30752c2012-10-09 19:52:38 +00001911/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1912/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001913static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
1914 ArgStringList &CmdArgs, bool IsCXX,
1915 bool HasOtherSanitizerRt) {
Nick Lewycky24921692013-10-19 00:27:23 +00001916 // Need a copy of sanitizer_common. This could come from another sanitizer
1917 // runtime; if we're not including one, include our own copy.
1918 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001919 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001920
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001921 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001922
1923 // Only include the bits of the runtime which need a C++ ABI library if
1924 // we're linking in C++ mode.
1925 if (IsCXX)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001926 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false);
Richard Smithe30752c2012-10-09 19:52:38 +00001927}
1928
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001929static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
1930 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00001931 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001932 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
1933}
1934
1935// Should be called before we add C++ ABI library.
1936static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
1937 ArgStringList &CmdArgs) {
1938 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
1939 const Driver &D = TC.getDriver();
1940 if (Sanitize.needsUbsanRt())
1941 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
1942 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
1943 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
1944 if (Sanitize.needsAsanRt())
1945 addAsanRT(TC, Args, CmdArgs);
1946 if (Sanitize.needsTsanRt())
1947 addTsanRT(TC, Args, CmdArgs);
1948 if (Sanitize.needsMsanRt())
1949 addMsanRT(TC, Args, CmdArgs);
1950 if (Sanitize.needsLsanRt())
1951 addLsanRT(TC, Args, CmdArgs);
1952 if (Sanitize.needsDfsanRt())
1953 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00001954}
1955
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001956static bool shouldUseFramePointerForTarget(const ArgList &Args,
1957 const llvm::Triple &Triple) {
1958 switch (Triple.getArch()) {
1959 // Don't use a frame pointer on linux if optimizing for certain targets.
1960 case llvm::Triple::mips64:
1961 case llvm::Triple::mips64el:
1962 case llvm::Triple::mips:
1963 case llvm::Triple::mipsel:
1964 case llvm::Triple::systemz:
1965 case llvm::Triple::x86:
1966 case llvm::Triple::x86_64:
1967 if (Triple.isOSLinux())
1968 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1969 if (!A->getOption().matches(options::OPT_O0))
1970 return false;
1971 return true;
1972 case llvm::Triple::xcore:
1973 return false;
1974 default:
1975 return true;
1976 }
1977}
1978
Rafael Espindola224dd632011-12-14 21:02:23 +00001979static bool shouldUseFramePointer(const ArgList &Args,
1980 const llvm::Triple &Triple) {
1981 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1982 options::OPT_fomit_frame_pointer))
1983 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1984
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001985 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00001986}
1987
Eric Christopherb7d97e92013-04-03 01:58:53 +00001988static bool shouldUseLeafFramePointer(const ArgList &Args,
1989 const llvm::Triple &Triple) {
1990 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1991 options::OPT_momit_leaf_frame_pointer))
1992 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1993
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001994 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00001995}
1996
Rafael Espindolac7367ff2013-08-10 01:40:10 +00001997/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00001998static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00001999 SmallString<128> cwd;
2000 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002001 CmdArgs.push_back("-fdebug-compilation-dir");
2002 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002003 }
2004}
2005
Eric Christopherd3804002013-02-22 20:12:52 +00002006static const char *SplitDebugName(const ArgList &Args,
2007 const InputInfoList &Inputs) {
2008 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2009 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2010 SmallString<128> T(FinalOutput->getValue());
2011 llvm::sys::path::replace_extension(T, "dwo");
2012 return Args.MakeArgString(T);
2013 } else {
2014 // Use the compilation dir.
2015 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2016 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2017 llvm::sys::path::replace_extension(F, "dwo");
2018 T += F;
2019 return Args.MakeArgString(F);
2020 }
2021}
2022
2023static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2024 const Tool &T, const JobAction &JA,
2025 const ArgList &Args, const InputInfo &Output,
2026 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002027 ArgStringList ExtractArgs;
2028 ExtractArgs.push_back("--extract-dwo");
2029
2030 ArgStringList StripArgs;
2031 StripArgs.push_back("--strip-dwo");
2032
2033 // Grabbing the output of the earlier compile step.
2034 StripArgs.push_back(Output.getFilename());
2035 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002036 ExtractArgs.push_back(OutFile);
2037
2038 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002039 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002040
2041 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002042 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002043
2044 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002045 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002046}
2047
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002048/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2049static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2050 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002051 if (A->getOption().matches(options::OPT_O4) ||
2052 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002053 return true;
2054
2055 if (A->getOption().matches(options::OPT_O0))
2056 return false;
2057
2058 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2059
Rafael Espindola91780de2013-08-26 14:05:41 +00002060 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002061 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002062 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002063 return true;
2064
2065 // Don't vectorize -Oz.
2066 if (S == "z")
2067 return false;
2068
2069 unsigned OptLevel = 0;
2070 if (S.getAsInteger(10, OptLevel))
2071 return false;
2072
2073 return OptLevel > 1;
2074 }
2075
2076 return false;
2077}
2078
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002079/// Add -x lang to \p CmdArgs for \p Input.
2080static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2081 ArgStringList &CmdArgs) {
2082 // When using -verify-pch, we don't want to provide the type
2083 // 'precompiled-header' if it was inferred from the file extension
2084 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2085 return;
2086
2087 CmdArgs.push_back("-x");
2088 if (Args.hasArg(options::OPT_rewrite_objc))
2089 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2090 else
2091 CmdArgs.push_back(types::getTypeName(Input.getType()));
2092}
2093
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002094void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002095 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002096 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002097 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002098 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002099 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2100 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002101 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002102 ArgStringList CmdArgs;
2103
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002104 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
2105 bool IsWindowsCygnus = getToolChain().getTriple().isWindowsCygwinEnvironment();
2106 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2107
Daniel Dunbare521a892009-03-31 20:53:55 +00002108 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2109
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002110 // Invoke ourselves in -cc1 mode.
2111 //
2112 // FIXME: Implement custom jobs for internal actions.
2113 CmdArgs.push_back("-cc1");
2114
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002115 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002116 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002117 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002118 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002119
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002120 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002121 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002122
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002123 if (isa<AnalyzeJobAction>(JA)) {
2124 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2125 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002126 } else if (isa<MigrateJobAction>(JA)) {
2127 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002128 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002129 if (Output.getType() == types::TY_Dependencies)
2130 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002131 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002132 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002133 if (Args.hasArg(options::OPT_rewrite_objc) &&
2134 !Args.hasArg(options::OPT_g_Group))
2135 CmdArgs.push_back("-P");
2136 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002137 } else if (isa<AssembleJobAction>(JA)) {
2138 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002139
David Blaikie9260ed62013-07-25 21:19:01 +00002140 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002141
2142 // Also ignore explicit -force_cpusubtype_ALL option.
2143 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002144 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002145 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002146 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002147
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002148 if (JA.getType() == types::TY_Nothing)
2149 CmdArgs.push_back("-fsyntax-only");
2150 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002151 CmdArgs.push_back("-emit-pch");
2152 else
2153 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002154 } else if (isa<VerifyPCHJobAction>(JA)) {
2155 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002156 } else {
2157 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002158
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002159 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002160 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002161 } else if (JA.getType() == types::TY_LLVM_IR ||
2162 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002163 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002164 } else if (JA.getType() == types::TY_LLVM_BC ||
2165 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002166 CmdArgs.push_back("-emit-llvm-bc");
2167 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002168 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002169 } else if (JA.getType() == types::TY_AST) {
2170 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002171 } else if (JA.getType() == types::TY_ModuleFile) {
2172 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002173 } else if (JA.getType() == types::TY_RewrittenObjC) {
2174 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002175 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002176 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2177 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002178 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002179 } else {
2180 assert(JA.getType() == types::TY_PP_Asm &&
2181 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002182 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002183 }
2184
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002185 // The make clang go fast button.
2186 CmdArgs.push_back("-disable-free");
2187
John McCallbb79b5f2010-02-13 03:50:24 +00002188 // Disable the verification pass in -asserts builds.
2189#ifdef NDEBUG
2190 CmdArgs.push_back("-disable-llvm-verifier");
2191#endif
2192
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002193 // Set the main file name, so that debug info works even with
2194 // -save-temps.
2195 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002196 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002197
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002198 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002199 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002200 if (Args.hasArg(options::OPT_static))
2201 CmdArgs.push_back("-static-define");
2202
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002203 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002204 // Enable region store model by default.
2205 CmdArgs.push_back("-analyzer-store=region");
2206
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002207 // Treat blocks as analysis entry points.
2208 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2209
Ted Kremenek49c79792011-03-24 00:28:47 +00002210 CmdArgs.push_back("-analyzer-eagerly-assume");
2211
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002212 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002213 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002214 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002215
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002216 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002217 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002218
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002219 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002220 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002221
2222 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002223
Jordan Rose10ad0812013-04-05 17:55:07 +00002224 if (types::isCXX(Inputs[0].getType()))
2225 CmdArgs.push_back("-analyzer-checker=cplusplus");
2226
Ted Kremenek37e96522012-01-26 02:27:38 +00002227 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00002228 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2229 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2230 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2231 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2232 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2233 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002234 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002235
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002236 // Set the output format. The default is plist, for (lame) historical
2237 // reasons.
2238 CmdArgs.push_back("-analyzer-output");
2239 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002240 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002241 else
2242 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002243
Ted Kremenekfe449a22010-03-22 22:32:05 +00002244 // Disable the presentation of standard compiler warnings when
2245 // using --analyze. We only want to show static analyzer diagnostics
2246 // or frontend errors.
2247 CmdArgs.push_back("-w");
2248
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002249 // Add -Xanalyzer arguments when running as analyzer.
2250 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002251 }
2252
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002253 CheckCodeGenerationOptions(D, Args);
2254
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002255 bool PIE = getToolChain().isPIEDefault();
2256 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002257 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002258
Alexey Bataev40e75222014-01-28 06:30:35 +00002259 // Android-specific defaults for PIC/PIE
2260 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2261 switch (getToolChain().getTriple().getArch()) {
2262 case llvm::Triple::arm:
2263 case llvm::Triple::thumb:
2264 case llvm::Triple::mips:
2265 case llvm::Triple::mipsel:
2266 case llvm::Triple::mips64:
2267 case llvm::Triple::mips64el:
2268 PIC = true; // "-fpic"
2269 break;
2270
2271 case llvm::Triple::x86:
2272 case llvm::Triple::x86_64:
2273 PIC = true; // "-fPIC"
2274 IsPICLevelTwo = true;
2275 break;
2276
2277 default:
2278 break;
2279 }
2280 }
2281
Alexey Samsonov090301e2013-04-09 12:28:19 +00002282 // For the PIC and PIE flag options, this logic is different from the
2283 // legacy logic in very old versions of GCC, as that logic was just
2284 // a bug no one had ever fixed. This logic is both more rational and
2285 // consistent with GCC's new logic now that the bugs are fixed. The last
2286 // argument relating to either PIC or PIE wins, and no other argument is
2287 // used. If the last argument is any flavor of the '-fno-...' arguments,
2288 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2289 // at the same level.
2290 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2291 options::OPT_fpic, options::OPT_fno_pic,
2292 options::OPT_fPIE, options::OPT_fno_PIE,
2293 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002294 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2295 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002296 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002297 if (LastPICArg) {
2298 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002299 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2300 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2301 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2302 PIC = PIE || O.matches(options::OPT_fPIC) ||
2303 O.matches(options::OPT_fpic);
2304 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2305 O.matches(options::OPT_fPIC);
2306 } else {
2307 PIE = PIC = false;
2308 }
2309 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002310 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002311
Nick Lewycky609dd662013-10-11 03:33:53 +00002312 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002313 // specified while enabling PIC enabled level 1 PIC, just force it back to
2314 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2315 // informal testing).
2316 if (PIC && getToolChain().getTriple().isOSDarwin())
2317 IsPICLevelTwo |= getToolChain().isPICDefault();
2318
Chandler Carruthc0c04552012-04-08 16:40:35 +00002319 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2320 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002321 llvm::Triple Triple(TripleStr);
Eric Christopher8d56caa2013-02-18 01:16:37 +00002322 if (KernelOrKext &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002323 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002324 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002325 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002326 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002327
Chandler Carruth76a943b2012-11-19 03:52:03 +00002328 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2329 // This is a very special mode. It trumps the other modes, almost no one
2330 // uses it, and it isn't even valid on any OS but Darwin.
2331 if (!getToolChain().getTriple().isOSDarwin())
2332 D.Diag(diag::err_drv_unsupported_opt_for_target)
2333 << A->getSpelling() << getToolChain().getTriple().str();
2334
2335 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2336
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002337 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002338 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002339
Chandler Carruth76a943b2012-11-19 03:52:03 +00002340 // Only a forced PIC mode can cause the actual compile to have PIC defines
2341 // etc., no flags are sufficient. This behavior was selected to closely
2342 // match that of llvm-gcc and Apple GCC before that.
2343 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2344 CmdArgs.push_back("-pic-level");
2345 CmdArgs.push_back("2");
2346 }
2347 } else {
2348 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2349 // handled in Clang's IRGen by the -pie-level flag.
2350 CmdArgs.push_back("-mrelocation-model");
2351 CmdArgs.push_back(PIC ? "pic" : "static");
2352
2353 if (PIC) {
2354 CmdArgs.push_back("-pic-level");
2355 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2356 if (PIE) {
2357 CmdArgs.push_back("-pie-level");
2358 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2359 }
2360 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002361 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002362
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002363 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2364 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002365 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002366
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002367 // LLVM Code Generator Options.
2368
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002369 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2370 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002371 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002372 }
2373
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002374 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2375 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002376 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002377 D.Diag(diag::err_drv_unsupported_opt_for_target)
2378 << A->getSpelling() << getToolChain().getTriple().str();
2379 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2380 CmdArgs.push_back("-fpcc-struct-return");
2381 } else {
2382 assert(A->getOption().matches(options::OPT_freg_struct_return));
2383 CmdArgs.push_back("-freg-struct-return");
2384 }
2385 }
2386
Roman Divacky65b88cd2011-03-01 17:40:53 +00002387 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2388 CmdArgs.push_back("-mrtd");
2389
Rafael Espindola224dd632011-12-14 21:02:23 +00002390 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002391 CmdArgs.push_back("-mdisable-fp-elim");
2392 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2393 options::OPT_fno_zero_initialized_in_bss))
2394 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002395
2396 bool OFastEnabled = isOptimizationLevelFast(Args);
2397 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2398 // enabled. This alias option is being used to simplify the hasFlag logic.
2399 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2400 options::OPT_fstrict_aliasing;
2401 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Rafael Espindola8f41aee2013-11-17 22:42:24 +00002402 options::OPT_fno_strict_aliasing, true))
Dan Gohman10169b92010-10-14 22:36:56 +00002403 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002404 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2405 options::OPT_fno_struct_path_tbaa))
2406 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002407 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2408 false))
2409 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002410 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2411 options::OPT_fno_optimize_sibling_calls))
2412 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002413
Eric Christopher006208c2013-04-04 06:29:47 +00002414 // Handle segmented stacks.
2415 if (Args.hasArg(options::OPT_fsplit_stack))
2416 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002417
2418 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2419 // This alias option is being used to simplify the getLastArg logic.
2420 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2421 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002422
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002423 // Handle various floating point optimization flags, mapping them to the
2424 // appropriate LLVM code generation flags. The pattern for all of these is to
2425 // default off the codegen optimizations, and if any flag enables them and no
2426 // flag disables them after the flag enabling them, enable the codegen
2427 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002428 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002429 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002430 options::OPT_ffinite_math_only,
2431 options::OPT_fno_finite_math_only,
2432 options::OPT_fhonor_infinities,
2433 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002434 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2435 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002436 A->getOption().getID() != options::OPT_fhonor_infinities)
2437 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002438 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002439 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002440 options::OPT_ffinite_math_only,
2441 options::OPT_fno_finite_math_only,
2442 options::OPT_fhonor_nans,
2443 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002444 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2445 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002446 A->getOption().getID() != options::OPT_fhonor_nans)
2447 CmdArgs.push_back("-menable-no-nans");
2448
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002449 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2450 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002451 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002452 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002453 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002454 options::OPT_fno_math_errno)) {
2455 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2456 // However, turning *off* -ffast_math merely restores the toolchain default
2457 // (which may be false).
2458 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2459 A->getOption().getID() == options::OPT_ffast_math ||
2460 A->getOption().getID() == options::OPT_Ofast)
2461 MathErrno = false;
2462 else if (A->getOption().getID() == options::OPT_fmath_errno)
2463 MathErrno = true;
2464 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002465 if (MathErrno)
2466 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002467
2468 // There are several flags which require disabling very specific
2469 // optimizations. Any of these being disabled forces us to turn off the
2470 // entire set of LLVM optimizations, so collect them through all the flag
2471 // madness.
2472 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002473 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002474 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002475 options::OPT_funsafe_math_optimizations,
2476 options::OPT_fno_unsafe_math_optimizations,
2477 options::OPT_fassociative_math,
2478 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002479 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2480 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002481 A->getOption().getID() != options::OPT_fno_associative_math)
2482 AssociativeMath = true;
2483 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002484 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002485 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002486 options::OPT_funsafe_math_optimizations,
2487 options::OPT_fno_unsafe_math_optimizations,
2488 options::OPT_freciprocal_math,
2489 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002490 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2491 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002492 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2493 ReciprocalMath = true;
2494 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002495 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002496 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002497 options::OPT_funsafe_math_optimizations,
2498 options::OPT_fno_unsafe_math_optimizations,
2499 options::OPT_fsigned_zeros,
2500 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002501 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2502 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002503 A->getOption().getID() != options::OPT_fsigned_zeros)
2504 SignedZeros = false;
2505 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002506 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002507 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002508 options::OPT_funsafe_math_optimizations,
2509 options::OPT_fno_unsafe_math_optimizations,
2510 options::OPT_ftrapping_math,
2511 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002512 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2513 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002514 A->getOption().getID() != options::OPT_ftrapping_math)
2515 TrappingMath = false;
2516 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2517 !TrappingMath)
2518 CmdArgs.push_back("-menable-unsafe-fp-math");
2519
Lang Hamesaa53b932012-07-06 00:59:19 +00002520
2521 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002522 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002523 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002524 options::OPT_ffp_contract)) {
2525 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002526 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002527 if (Val == "fast" || Val == "on" || Val == "off") {
2528 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2529 } else {
2530 D.Diag(diag::err_drv_unsupported_option_argument)
2531 << A->getOption().getName() << Val;
2532 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002533 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2534 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002535 // If fast-math is set then set the fp-contract mode to fast.
2536 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2537 }
2538 }
2539
Bob Wilson6a039162012-07-19 03:52:53 +00002540 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2541 // and if we find them, tell the frontend to provide the appropriate
2542 // preprocessor macros. This is distinct from enabling any optimizations as
2543 // these options induce language changes which must survive serialization
2544 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002545 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2546 options::OPT_fno_fast_math))
2547 if (!A->getOption().matches(options::OPT_fno_fast_math))
2548 CmdArgs.push_back("-ffast-math");
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002549 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2550 if (A->getOption().matches(options::OPT_ffinite_math_only))
2551 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002552
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002553 // Decide whether to use verbose asm. Verbose assembly is the default on
2554 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002555 bool IsIntegratedAssemblerDefault =
2556 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002557 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002558 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002559 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002560 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002561
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002562 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002563 IsIntegratedAssemblerDefault))
2564 CmdArgs.push_back("-no-integrated-as");
2565
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002566 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2567 CmdArgs.push_back("-mdebug-pass");
2568 CmdArgs.push_back("Structure");
2569 }
2570 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2571 CmdArgs.push_back("-mdebug-pass");
2572 CmdArgs.push_back("Arguments");
2573 }
2574
John McCall8517abc2010-02-19 02:45:38 +00002575 // Enable -mconstructor-aliases except on darwin, where we have to
2576 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002577 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002578 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002579
John McCall7ef5cb32011-03-18 02:56:14 +00002580 // Darwin's kernel doesn't support guard variables; just die if we
2581 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002582 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002583 CmdArgs.push_back("-fforbid-guard-variables");
2584
Douglas Gregordbe39272011-02-01 15:15:22 +00002585 if (Args.hasArg(options::OPT_mms_bitfields)) {
2586 CmdArgs.push_back("-mms-bitfields");
2587 }
John McCall8517abc2010-02-19 02:45:38 +00002588
Daniel Dunbar306945d2009-09-16 06:17:29 +00002589 // This is a coarse approximation of what llvm-gcc actually does, both
2590 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2591 // complicated ways.
2592 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002593 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2594 options::OPT_fno_asynchronous_unwind_tables,
2595 (getToolChain().IsUnwindTablesDefault() ||
2596 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2597 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002598 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2599 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002600 CmdArgs.push_back("-munwind-tables");
2601
Chandler Carruth05fb5852012-11-21 23:40:23 +00002602 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002603
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002604 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2605 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002606 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002607 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002608
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002609 // FIXME: Handle -mtune=.
2610 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002611
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002612 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002613 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002614 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002615 }
2616
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002617 // Add the target cpu
2618 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2619 llvm::Triple ETriple(ETripleStr);
2620 std::string CPU = getCPUName(Args, ETriple);
2621 if (!CPU.empty()) {
2622 CmdArgs.push_back("-target-cpu");
2623 CmdArgs.push_back(Args.MakeArgString(CPU));
2624 }
2625
Rafael Espindolaeb265472013-08-21 21:59:03 +00002626 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2627 CmdArgs.push_back("-mfpmath");
2628 CmdArgs.push_back(A->getValue());
2629 }
2630
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002631 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002632 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002633
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002634 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002635 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002636 default:
2637 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002638
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002639 case llvm::Triple::arm:
2640 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002641 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002642 break;
2643
Eric Christopher0b26a612010-03-02 02:41:08 +00002644 case llvm::Triple::mips:
2645 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002646 case llvm::Triple::mips64:
2647 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002648 AddMIPSTargetArgs(Args, CmdArgs);
2649 break;
2650
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002651 case llvm::Triple::sparc:
2652 AddSparcTargetArgs(Args, CmdArgs);
2653 break;
2654
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002655 case llvm::Triple::x86:
2656 case llvm::Triple::x86_64:
2657 AddX86TargetArgs(Args, CmdArgs);
2658 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002659
2660 case llvm::Triple::hexagon:
2661 AddHexagonTargetArgs(Args, CmdArgs);
2662 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002663 }
2664
Hans Wennborg75958c42013-08-08 00:17:41 +00002665 // Add clang-cl arguments.
2666 if (getToolChain().getDriver().IsCLMode())
2667 AddClangCLArgs(Args, CmdArgs);
2668
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002669 // Pass the linker version in use.
2670 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2671 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002672 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002673 }
2674
Eric Christopherb7d97e92013-04-03 01:58:53 +00002675 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002676 CmdArgs.push_back("-momit-leaf-frame-pointer");
2677
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002678 // Explicitly error on some things we know we don't support and can't just
2679 // ignore.
2680 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002681 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2682 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002683 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002684 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002685 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002686 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2687 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002688 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002689 << Unsupported->getOption().getName();
2690 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002691 }
2692
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002693 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002694 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002695 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002696 CmdArgs.push_back("-header-include-file");
2697 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2698 D.CCPrintHeadersFilename : "-");
2699 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002700 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002701 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002702
Chad Rosierbe10f982011-08-02 17:58:04 +00002703 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002704 CmdArgs.push_back("-diagnostic-log-file");
2705 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2706 D.CCLogDiagnosticsFilename : "-");
2707 }
2708
Manman Ren17bdb0f2013-11-20 20:22:14 +00002709 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2710 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002711 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002712 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002713 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002714 // FIXME: we should support specifying dwarf version with
2715 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002716 CmdArgs.push_back("-gline-tables-only");
Adrian Prantl549c5142014-02-17 17:40:52 +00002717 // Default is dwarf-2 for darwin.
2718 if (getToolChain().getTriple().isOSDarwin())
2719 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002720 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002721 CmdArgs.push_back("-gdwarf-2");
2722 else if (A->getOption().matches(options::OPT_gdwarf_3))
2723 CmdArgs.push_back("-gdwarf-3");
2724 else if (A->getOption().matches(options::OPT_gdwarf_4))
2725 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002726 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002727 !A->getOption().matches(options::OPT_ggdb0)) {
2728 // Default is dwarf-2 for darwin.
2729 if (getToolChain().getTriple().isOSDarwin())
2730 CmdArgs.push_back("-gdwarf-2");
2731 else
2732 CmdArgs.push_back("-g");
2733 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002734 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002735
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002736 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2737 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002738 if (Args.hasArg(options::OPT_gcolumn_info))
2739 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002740
Eric Christopher138c32b2013-09-13 22:37:55 +00002741 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002742 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2743 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002744 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002745 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002746 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002747 CmdArgs.push_back("-g");
2748 CmdArgs.push_back("-backend-option");
2749 CmdArgs.push_back("-split-dwarf=Enable");
2750 }
2751
Eric Christopher138c32b2013-09-13 22:37:55 +00002752 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2753 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2754 CmdArgs.push_back("-backend-option");
2755 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2756 }
Eric Christophereec89c22013-06-18 00:03:50 +00002757
Eric Christopher0d403d22014-02-14 01:27:03 +00002758 // -gdwarf-aranges turns on the emission of the aranges section in the
2759 // backend.
2760 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2761 CmdArgs.push_back("-backend-option");
2762 CmdArgs.push_back("-generate-arange-section");
2763 }
2764
David Blaikief36d9ba2014-01-27 18:52:43 +00002765 if (Args.hasFlag(options::OPT_fdebug_types_section,
2766 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002767 CmdArgs.push_back("-backend-option");
2768 CmdArgs.push_back("-generate-type-units");
2769 }
Eric Christophereec89c22013-06-18 00:03:50 +00002770
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002771 if (Args.hasFlag(options::OPT_ffunction_sections,
2772 options::OPT_fno_function_sections, false)) {
2773 CmdArgs.push_back("-ffunction-sections");
2774 }
2775
2776 if (Args.hasFlag(options::OPT_fdata_sections,
2777 options::OPT_fno_data_sections, false)) {
2778 CmdArgs.push_back("-fdata-sections");
2779 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002780
Chris Lattner3c77a352010-06-22 00:03:40 +00002781 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2782
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002783 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2784 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2785 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2786 D.Diag(diag::err_drv_argument_not_allowed_with)
2787 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2788
2789 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2790
2791 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2792 A->render(Args, CmdArgs);
2793 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2794 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
2795
Nick Lewycky207bce32011-04-21 23:44:07 +00002796 if (Args.hasArg(options::OPT_ftest_coverage) ||
2797 Args.hasArg(options::OPT_coverage))
2798 CmdArgs.push_back("-femit-coverage-notes");
2799 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2800 Args.hasArg(options::OPT_coverage))
2801 CmdArgs.push_back("-femit-coverage-data");
2802
Nick Lewycky480cb992011-05-04 20:46:58 +00002803 if (C.getArgs().hasArg(options::OPT_c) ||
2804 C.getArgs().hasArg(options::OPT_S)) {
2805 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002806 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00002807 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00002808 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002809 SmallString<128> Pwd;
2810 if (!llvm::sys::fs::current_path(Pwd)) {
2811 llvm::sys::path::append(Pwd, CoverageFilename.str());
2812 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00002813 }
2814 }
Eric Christophere30f61c2013-02-22 00:24:40 +00002815 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002816 }
2817 }
2818
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002819 // Pass options for controlling the default header search paths.
2820 if (Args.hasArg(options::OPT_nostdinc)) {
2821 CmdArgs.push_back("-nostdsysteminc");
2822 CmdArgs.push_back("-nobuiltininc");
2823 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002824 if (Args.hasArg(options::OPT_nostdlibinc))
2825 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002826 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2827 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2828 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002829
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002830 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002831 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002832 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002833
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002834 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2835
Ted Kremenekf7639e12012-03-06 20:06:33 +00002836 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00002837 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002838 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002839 options::OPT_ccc_arcmt_modify,
2840 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002841 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002842 switch (A->getOption().getID()) {
2843 default:
2844 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002845 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002846 CmdArgs.push_back("-arcmt-check");
2847 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002848 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002849 CmdArgs.push_back("-arcmt-modify");
2850 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002851 case options::OPT_ccc_arcmt_migrate:
2852 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002853 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002854 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002855
2856 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2857 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002858 break;
John McCalld70fb982011-06-15 23:25:17 +00002859 }
2860 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00002861 } else {
2862 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2863 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2864 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00002865 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002866
Ted Kremenekf7639e12012-03-06 20:06:33 +00002867 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2868 if (ARCMTEnabled) {
2869 D.Diag(diag::err_drv_argument_not_allowed_with)
2870 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2871 }
2872 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002873 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002874
2875 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002876 options::OPT_objcmt_migrate_subscripting,
2877 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002878 // None specified, means enable them all.
2879 CmdArgs.push_back("-objcmt-migrate-literals");
2880 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002881 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002882 } else {
2883 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2884 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002885 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002886 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00002887 } else {
2888 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2889 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2890 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2891 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2892 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2893 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2894 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2895 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2896 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2897 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2898 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2899 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2900 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00002901 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00002902 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002903 }
2904
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002905 // Add preprocessing options like -I, -D, etc. if we are using the
2906 // preprocessor.
2907 //
2908 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002909 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00002910 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002911
Rafael Espindolaa7431922011-07-21 23:40:37 +00002912 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2913 // that "The compiler can only warn and ignore the option if not recognized".
2914 // When building with ccache, it will pass -D options to clang even on
2915 // preprocessed inputs and configure concludes that -fPIC is not supported.
2916 Args.ClaimAllArgs(options::OPT_D);
2917
Alp Toker7874bdc2013-11-15 20:40:58 +00002918 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00002919 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2920 if (A->getOption().matches(options::OPT_O4)) {
2921 CmdArgs.push_back("-O3");
2922 D.Diag(diag::warn_O4_is_O3);
2923 } else {
2924 A->render(Args, CmdArgs);
2925 }
2926 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002927
Chad Rosier86b82082012-12-12 20:06:31 +00002928 // Don't warn about unused -flto. This can happen when we're preprocessing or
2929 // precompiling.
2930 Args.ClaimAllArgs(options::OPT_flto);
2931
Daniel Dunbar945577c2009-10-29 02:24:45 +00002932 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002933 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2934 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002935 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002936 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002937
2938 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00002939 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002940 //
2941 // If a std is supplied, only add -trigraphs if it follows the
2942 // option.
2943 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2944 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002945 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002946 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002947 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002948 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002949 else
2950 Std->render(Args, CmdArgs);
2951
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002952 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2953 options::OPT_trigraphs))
2954 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002955 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002956 } else {
2957 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002958 //
2959 // FIXME: Clang doesn't correctly handle -std= when the input language
2960 // doesn't match. For the time being just ignore this for C++ inputs;
2961 // eventually we want to do all the standard defaulting here instead of
2962 // splitting it between the driver and clang -cc1.
2963 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002964 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2965 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002966 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00002967 CmdArgs.push_back("-std=c++11");
2968
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002969 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002970 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002971
Richard Smith282b4492013-09-04 22:50:31 +00002972 // GCC's behavior for -Wwrite-strings is a bit strange:
2973 // * In C, this "warning flag" changes the types of string literals from
2974 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2975 // for the discarded qualifier.
2976 // * In C++, this is just a normal warning flag.
2977 //
2978 // Implementing this warning correctly in C is hard, so we follow GCC's
2979 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2980 // a non-const char* in C, rather than using this crude hack.
2981 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00002982 // FIXME: This should behave just like a warning flag, and thus should also
2983 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
2984 Arg *WriteStrings =
2985 Args.getLastArg(options::OPT_Wwrite_strings,
2986 options::OPT_Wno_write_strings, options::OPT_w);
2987 if (WriteStrings &&
2988 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00002989 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00002990 }
2991
Chandler Carruth61fbf622011-04-23 09:27:53 +00002992 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002993 // during C++ compilation, which it is by default. GCC keeps this define even
2994 // in the presence of '-w', match this behavior bug-for-bug.
2995 if (types::isCXX(InputType) &&
2996 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2997 true)) {
2998 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002999 }
3000
Chandler Carruthe0391482010-05-22 02:21:53 +00003001 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3002 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3003 if (Asm->getOption().matches(options::OPT_fasm))
3004 CmdArgs.push_back("-fgnu-keywords");
3005 else
3006 CmdArgs.push_back("-fno-gnu-keywords");
3007 }
3008
Rafael Espindola4cfa7972011-05-02 17:43:32 +00003009 if (ShouldDisableCFI(Args, getToolChain()))
3010 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00003011
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003012 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3013 CmdArgs.push_back("-fno-dwarf-directory-asm");
3014
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003015 if (ShouldDisableAutolink(Args, getToolChain()))
3016 CmdArgs.push_back("-fno-autolink");
3017
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003018 // Add in -fdebug-compilation-dir if necessary.
3019 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003020
Richard Smith9a568822011-11-21 19:36:32 +00003021 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3022 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003023 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003024 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003025 }
3026
Richard Smith79c927b2013-11-06 19:31:51 +00003027 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3028 CmdArgs.push_back("-foperator-arrow-depth");
3029 CmdArgs.push_back(A->getValue());
3030 }
3031
Richard Smith9a568822011-11-21 19:36:32 +00003032 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3033 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003034 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003035 }
3036
Richard Smitha3d3bd22013-05-08 02:12:03 +00003037 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3038 CmdArgs.push_back("-fconstexpr-steps");
3039 CmdArgs.push_back(A->getValue());
3040 }
3041
Richard Smithb3a14522013-02-22 01:59:51 +00003042 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3043 CmdArgs.push_back("-fbracket-depth");
3044 CmdArgs.push_back(A->getValue());
3045 }
3046
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003047 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3048 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003049 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003050 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003051 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3052 } else
3053 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003054 }
3055
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003056
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003057 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003058 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003059
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003060 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3061 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003062 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003063 }
David Chisnall5778fce2009-08-31 16:41:57 +00003064
Chris Lattnere23003d2010-01-09 21:54:33 +00003065 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3066 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003067 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003068 }
3069
Chris Lattnerb35583d2010-04-07 20:49:23 +00003070 CmdArgs.push_back("-ferror-limit");
3071 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003072 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003073 else
3074 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003075
Chandler Carrutha77a7272010-05-06 04:55:18 +00003076 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3077 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003078 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003079 }
3080
3081 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3082 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003083 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003084 }
3085
Richard Smithf6f003a2011-12-16 19:06:07 +00003086 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3087 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003088 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003089 }
3090
Daniel Dunbar2c978472009-11-04 06:24:47 +00003091 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003092 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003093 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003094 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003095 } else {
3096 // If -fmessage-length=N was not specified, determine whether this is a
3097 // terminal and, if so, implicitly define -fmessage-length appropriately.
3098 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003099 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003100 }
3101
John McCallb4a99d32013-02-19 01:57:35 +00003102 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3103 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3104 options::OPT_fvisibility_ms_compat)) {
3105 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3106 CmdArgs.push_back("-fvisibility");
3107 CmdArgs.push_back(A->getValue());
3108 } else {
3109 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3110 CmdArgs.push_back("-fvisibility");
3111 CmdArgs.push_back("hidden");
3112 CmdArgs.push_back("-ftype-visibility");
3113 CmdArgs.push_back("default");
3114 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003115 }
3116
Douglas Gregor08329632010-06-15 17:05:35 +00003117 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003118
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003119 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3120
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003121 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003122 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3123 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003124 CmdArgs.push_back("-ffreestanding");
3125
Daniel Dunbare357d562009-12-03 18:42:11 +00003126 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003127 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003128 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003129 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3130 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003131 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003132 // AltiVec language extensions aren't relevant for assembling.
3133 if (!isa<PreprocessJobAction>(JA) ||
3134 Output.getType() != types::TY_PP_Asm)
3135 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003136 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3137 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003138
Peter Collingbourne32701642013-11-01 18:16:25 +00003139 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3140 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003141
Will Dietz3676d562012-12-30 20:53:28 +00003142 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3143 options::OPT_fno_sanitize_recover,
3144 true))
3145 CmdArgs.push_back("-fno-sanitize-recover");
3146
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003147 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003148 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3149 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3150
Eric Christopher459d2712013-02-19 06:16:53 +00003151 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003152 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003153 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003154 getToolChain().getArch() == llvm::Triple::ppc64 ||
3155 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003156 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003157 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003158
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003159 if (getToolChain().SupportsProfiling())
3160 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003161
3162 // -flax-vector-conversions is default.
3163 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3164 options::OPT_fno_lax_vector_conversions))
3165 CmdArgs.push_back("-fno-lax-vector-conversions");
3166
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003167 if (Args.getLastArg(options::OPT_fapple_kext))
3168 CmdArgs.push_back("-fapple-kext");
3169
David Blaikie690f21e2012-06-14 18:55:27 +00003170 if (Args.hasFlag(options::OPT_frewrite_includes,
3171 options::OPT_fno_rewrite_includes, false))
3172 CmdArgs.push_back("-frewrite-includes");
3173
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003174 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003175 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003176 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003177 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3178 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003179
3180 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3181 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003182 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003183 }
3184
Bob Wilson14adb362012-02-03 06:27:22 +00003185 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003186
Chandler Carruth6e501032011-03-27 00:04:55 +00003187 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3188 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3189 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3190 options::OPT_fno_wrapv)) {
3191 if (A->getOption().matches(options::OPT_fwrapv))
3192 CmdArgs.push_back("-fwrapv");
3193 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3194 options::OPT_fno_strict_overflow)) {
3195 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3196 CmdArgs.push_back("-fwrapv");
3197 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003198
3199 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3200 options::OPT_fno_reroll_loops))
3201 if (A->getOption().matches(options::OPT_freroll_loops))
3202 CmdArgs.push_back("-freroll-loops");
3203
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003204 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003205 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3206 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003207
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003208 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3209
Mahesha S6a682be42012-10-27 07:47:56 +00003210
Daniel Dunbar4930e332009-11-17 08:07:36 +00003211 // -stack-protector=0 is default.
3212 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003213 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3214 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003215 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003216 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003217 if (A->getOption().matches(options::OPT_fstack_protector))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003218 StackProtectorLevel = LangOptions::SSPOn;
3219 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3220 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003221 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003222 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003223 } else {
3224 StackProtectorLevel =
3225 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3226 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003227 if (StackProtectorLevel) {
3228 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003229 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003230 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003231
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003232 // --param ssp-buffer-size=
3233 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3234 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003235 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003236 if (Str.startswith("ssp-buffer-size=")) {
3237 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003238 CmdArgs.push_back("-stack-protector-buffer-size");
3239 // FIXME: Verify the argument is a valid integer.
3240 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003241 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003242 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003243 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003244 }
3245
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003246 // Translate -mstackrealign
3247 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3248 false)) {
3249 CmdArgs.push_back("-backend-option");
3250 CmdArgs.push_back("-force-align-stack");
3251 }
3252 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3253 false)) {
3254 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3255 }
3256
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003257 if (Args.hasArg(options::OPT_mstack_alignment)) {
3258 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3259 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003260 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003261 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003262 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003263 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3264 options::OPT_munaligned_access)) {
3265 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3266 CmdArgs.push_back("-backend-option");
3267 CmdArgs.push_back("-arm-strict-align");
3268 } else {
3269 CmdArgs.push_back("-backend-option");
3270 CmdArgs.push_back("-arm-no-strict-align");
3271 }
Renato Golina146a482013-08-24 14:44:41 +00003272 }
Chad Rosier60027022012-11-09 17:29:19 +00003273 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003274
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003275 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3276 options::OPT_mno_restrict_it)) {
3277 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3278 CmdArgs.push_back("-backend-option");
3279 CmdArgs.push_back("-arm-restrict-it");
3280 } else {
3281 CmdArgs.push_back("-backend-option");
3282 CmdArgs.push_back("-arm-no-restrict-it");
3283 }
3284 }
3285
Daniel Dunbard18049a2009-04-07 21:16:11 +00003286 // Forward -f options with positive and negative forms; we translate
3287 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003288 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3289 StringRef fname = A->getValue();
3290 if (!llvm::sys::fs::exists(fname))
3291 D.Diag(diag::err_drv_no_such_file) << fname;
3292 else
3293 A->render(Args, CmdArgs);
3294 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003295
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003296 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003297 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003298 CmdArgs.push_back("-fapple-kext");
3299 if (!Args.hasArg(options::OPT_fbuiltin))
3300 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003301 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003302 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003303 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003304 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003305 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003306
Nuno Lopes13c88c72009-12-16 16:59:22 +00003307 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3308 options::OPT_fno_assume_sane_operator_new))
3309 CmdArgs.push_back("-fno-assume-sane-operator-new");
3310
Daniel Dunbar4930e332009-11-17 08:07:36 +00003311 // -fblocks=0 is default.
3312 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003313 getToolChain().IsBlocksDefault()) ||
3314 (Args.hasArg(options::OPT_fgnu_runtime) &&
3315 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3316 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003317 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003318
3319 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3320 !getToolChain().hasBlocksRuntime())
3321 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003322 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003323
Douglas Gregor226173a2012-01-18 15:19:58 +00003324 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3325 // users must also pass -fcxx-modules. The latter flag will disappear once the
3326 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003327 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003328 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3329 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3330 options::OPT_fno_cxx_modules,
3331 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003332 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003333 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003334 HaveModules = true;
3335 }
3336 }
3337
Daniel Jasper07e6c402013-08-05 20:26:17 +00003338 // -fmodule-maps enables module map processing (off by default) for header
3339 // checking. It is implied by -fmodules.
3340 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3341 false)) {
3342 CmdArgs.push_back("-fmodule-maps");
3343 }
3344
Daniel Jasperac42b752013-10-21 06:34:34 +00003345 // -fmodules-decluse checks that modules used are declared so (off by
3346 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003347 if (Args.hasFlag(options::OPT_fmodules_decluse,
3348 options::OPT_fno_modules_decluse,
3349 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003350 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003351 }
3352
Daniel Jasperac42b752013-10-21 06:34:34 +00003353 // -fmodule-name specifies the module that is currently being built (or
3354 // used for header checking by -fmodule-maps).
3355 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3356 A->claim();
3357 A->render(Args, CmdArgs);
3358 }
3359
3360 // -fmodule-map-file can be used to specify a file containing module
3361 // definitions.
3362 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3363 A->claim();
3364 A->render(Args, CmdArgs);
3365 }
3366
Douglas Gregor35b04d62013-02-07 19:01:24 +00003367 // If a module path was provided, pass it along. Otherwise, use a temporary
3368 // directory.
3369 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3370 A->claim();
3371 if (HaveModules) {
3372 A->render(Args, CmdArgs);
3373 }
3374 } else if (HaveModules) {
3375 SmallString<128> DefaultModuleCache;
3376 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3377 DefaultModuleCache);
Douglas Gregor23c7d672013-03-21 21:48:48 +00003378 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3379 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00003380 const char Arg[] = "-fmodules-cache-path=";
3381 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3382 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003383 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3384 }
3385
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003386 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path)) {
3387 A->claim();
3388 if (HaveModules) {
3389 A->render(Args, CmdArgs);
3390 }
3391 }
3392
Douglas Gregor35b04d62013-02-07 19:01:24 +00003393 // Pass through all -fmodules-ignore-macro arguments.
3394 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003395 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3396 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003397
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003398 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3399
3400 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3401 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3402 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3403
3404 Args.AddLastArg(CmdArgs,
3405 options::OPT_fmodules_validate_once_per_build_session);
3406 }
3407
Ben Langmuirdcf73862014-03-12 00:06:17 +00003408 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3409
John McCalldfea9982010-04-09 19:12:06 +00003410 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003411 if (Args.hasFlag(options::OPT_fno_access_control,
3412 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003413 false))
John McCall3155f572010-04-09 19:03:51 +00003414 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003415
Anders Carlssond470fef2010-11-21 00:09:52 +00003416 // -felide-constructors is the default.
3417 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3418 options::OPT_felide_constructors,
3419 false))
3420 CmdArgs.push_back("-fno-elide-constructors");
3421
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003422 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003423 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003424 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003425 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003426
Richard Smith52be6192012-11-05 22:04:41 +00003427 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003428 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003429 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003430 Args.getLastArg(options::OPT_mkernel,
3431 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003432 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003433 D.Diag(diag::err_drv_argument_not_allowed_with)
3434 << "-fsanitize=vptr" << NoRttiArg;
3435 }
3436 }
3437
Tony Linthicum76329bf2011-12-12 21:14:55 +00003438 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003439 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003440 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003441 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003442 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003443 CmdArgs.push_back("-fshort-enums");
3444
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003445 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003446 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003447 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003448 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003449
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003450 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003451 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003452 options::OPT_fno_threadsafe_statics))
3453 CmdArgs.push_back("-fno-threadsafe-statics");
3454
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003455 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003456 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3457 options::OPT_fno_use_cxa_atexit,
3458 !IsWindowsCygnus && !IsWindowsGNU &&
3459 getToolChain().getArch() != llvm::Triple::hexagon &&
3460 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003461 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003462 CmdArgs.push_back("-fno-use-cxa-atexit");
3463
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003464 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003465 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003466 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003467 CmdArgs.push_back("-fms-extensions");
3468
Francois Pichet1b4f1632011-09-17 04:32:15 +00003469 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003470 if (Args.hasFlag(options::OPT_fms_compatibility,
3471 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003472 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3473 options::OPT_fno_ms_extensions,
3474 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003475 CmdArgs.push_back("-fms-compatibility");
3476
Reid Klecknerc106fda2013-09-18 00:33:59 +00003477 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003478 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003479 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003480 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003481 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003482 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003483 else
3484 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3485 }
3486
3487
Eric Christopher5ecce122013-02-18 00:38:31 +00003488 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003489 if (Args.hasFlag(options::OPT_fborland_extensions,
3490 options::OPT_fno_borland_extensions, false))
3491 CmdArgs.push_back("-fborland-extensions");
3492
Francois Pichet02744872011-09-01 16:38:08 +00003493 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3494 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003495 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003496 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003497 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003498
Chandler Carruthe03aa552010-04-17 20:17:31 +00003499 // -fgnu-keywords default varies depending on language; only pass if
3500 // specified.
3501 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003502 options::OPT_fno_gnu_keywords))
3503 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003504
Rafael Espindola922a6242011-06-02 17:30:53 +00003505 if (Args.hasFlag(options::OPT_fgnu89_inline,
3506 options::OPT_fno_gnu89_inline,
3507 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003508 CmdArgs.push_back("-fgnu89-inline");
3509
Chad Rosier9c76d242012-03-15 22:31:42 +00003510 if (Args.hasArg(options::OPT_fno_inline))
3511 CmdArgs.push_back("-fno-inline");
3512
Chad Rosier64d6be92012-03-06 21:17:19 +00003513 if (Args.hasArg(options::OPT_fno_inline_functions))
3514 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003515
John McCall5fb5df92012-06-20 06:18:46 +00003516 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003517
John McCall5fb5df92012-06-20 06:18:46 +00003518 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003519 // legacy is the default. Except for deployment taget of 10.5,
3520 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3521 // gets ignored silently.
3522 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003523 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3524 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003525 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003526 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003527 if (getToolChain().UseObjCMixedDispatch())
3528 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3529 else
3530 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3531 }
3532 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003533
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003534 // When ObjectiveC legacy runtime is in effect on MacOSX,
3535 // turn on the option to do Array/Dictionary subscripting
3536 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003537 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3538 getToolChain().getTriple().isMacOSX() &&
3539 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3540 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003541 objcRuntime.isNeXTFamily())
3542 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3543
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003544 // -fencode-extended-block-signature=1 is default.
3545 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3546 CmdArgs.push_back("-fencode-extended-block-signature");
3547 }
3548
John McCall24fc0de2011-07-06 00:26:06 +00003549 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3550 // NOTE: This logic is duplicated in ToolChains.cpp.
3551 bool ARC = isObjCAutoRefCount(Args);
3552 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003553 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003554
John McCall24fc0de2011-07-06 00:26:06 +00003555 CmdArgs.push_back("-fobjc-arc");
3556
Chandler Carruth491db322011-11-04 07:34:47 +00003557 // FIXME: It seems like this entire block, and several around it should be
3558 // wrapped in isObjC, but for now we just use it here as this is where it
3559 // was being used previously.
3560 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3561 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3562 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3563 else
3564 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3565 }
3566
John McCall24fc0de2011-07-06 00:26:06 +00003567 // Allow the user to enable full exceptions code emission.
3568 // We define off for Objective-CC, on for Objective-C++.
3569 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3570 options::OPT_fno_objc_arc_exceptions,
3571 /*default*/ types::isCXX(InputType)))
3572 CmdArgs.push_back("-fobjc-arc-exceptions");
3573 }
3574
3575 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3576 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003577 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003578 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003579
John McCall24fc0de2011-07-06 00:26:06 +00003580 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3581 // takes precedence.
3582 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3583 if (!GCArg)
3584 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3585 if (GCArg) {
3586 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003587 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003588 << GCArg->getAsString(Args);
3589 } else if (getToolChain().SupportsObjCGC()) {
3590 GCArg->render(Args, CmdArgs);
3591 } else {
3592 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003593 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003594 << GCArg->getAsString(Args);
3595 }
3596 }
3597
John McCallb5f652e2011-06-22 00:53:57 +00003598 // Add exception args.
3599 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003600 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003601
3602 if (getToolChain().UseSjLjExceptions())
3603 CmdArgs.push_back("-fsjlj-exceptions");
3604
3605 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003606 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3607 options::OPT_fno_assume_sane_operator_new))
3608 CmdArgs.push_back("-fno-assume-sane-operator-new");
3609
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003610 // -fconstant-cfstrings is default, and may be subject to argument translation
3611 // on Darwin.
3612 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3613 options::OPT_fno_constant_cfstrings) ||
3614 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3615 options::OPT_mno_constant_cfstrings))
3616 CmdArgs.push_back("-fno-constant-cfstrings");
3617
John Thompsoned4e2952009-11-05 20:14:16 +00003618 // -fshort-wchar default varies depending on platform; only
3619 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003620 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3621 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003622 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003623
Hans Wennborg28c96312013-07-31 23:39:13 +00003624 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003625 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003626 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003627 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003628 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003629
Daniel Dunbar096ed292011-10-05 21:04:55 +00003630 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3631 // -fno-pack-struct doesn't apply to -fpack-struct=.
3632 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003633 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003634 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003635 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003636 } else if (Args.hasFlag(options::OPT_fpack_struct,
3637 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003638 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003639 }
3640
Robert Lytton0e076492013-08-13 09:43:10 +00003641 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003642 if (!Args.hasArg(options::OPT_fcommon))
3643 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003644 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003645 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003646
Daniel Dunbard18049a2009-04-07 21:16:11 +00003647 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003648 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003649 CmdArgs.push_back("-fno-common");
3650
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003651 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003652 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003653 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003654 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003655 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003656 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3657
Daniel Dunbar6358d682010-10-15 22:30:42 +00003658 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3659 if (!Args.hasFlag(options::OPT_ffor_scope,
3660 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003661 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003662 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3663
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003664 // -fcaret-diagnostics is default.
3665 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3666 options::OPT_fno_caret_diagnostics, true))
3667 CmdArgs.push_back("-fno-caret-diagnostics");
3668
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003669 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003670 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003671 options::OPT_fno_diagnostics_fixit_info))
3672 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003673
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003674 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003675 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003676 options::OPT_fno_diagnostics_show_option))
3677 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003678
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003679 if (const Arg *A =
3680 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3681 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003682 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003683 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003684
Douglas Gregor643c9222011-05-21 17:07:29 +00003685 if (const Arg *A =
3686 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3687 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003688 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003689 }
3690
Chandler Carruthb6766f02011-03-27 01:50:55 +00003691 if (Arg *A = Args.getLastArg(
3692 options::OPT_fdiagnostics_show_note_include_stack,
3693 options::OPT_fno_diagnostics_show_note_include_stack)) {
3694 if (A->getOption().matches(
3695 options::OPT_fdiagnostics_show_note_include_stack))
3696 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3697 else
3698 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3699 }
3700
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003701 // Color diagnostics are the default, unless the terminal doesn't support
3702 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003703 // Support both clang's -f[no-]color-diagnostics and gcc's
3704 // -f[no-]diagnostics-colors[=never|always|auto].
3705 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3706 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3707 it != ie; ++it) {
3708 const Option &O = (*it)->getOption();
3709 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3710 !O.matches(options::OPT_fdiagnostics_color) &&
3711 !O.matches(options::OPT_fno_color_diagnostics) &&
3712 !O.matches(options::OPT_fno_diagnostics_color) &&
3713 !O.matches(options::OPT_fdiagnostics_color_EQ))
3714 continue;
3715
3716 (*it)->claim();
3717 if (O.matches(options::OPT_fcolor_diagnostics) ||
3718 O.matches(options::OPT_fdiagnostics_color)) {
3719 ShowColors = Colors_On;
3720 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3721 O.matches(options::OPT_fno_diagnostics_color)) {
3722 ShowColors = Colors_Off;
3723 } else {
3724 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3725 StringRef value((*it)->getValue());
3726 if (value == "always")
3727 ShowColors = Colors_On;
3728 else if (value == "never")
3729 ShowColors = Colors_Off;
3730 else if (value == "auto")
3731 ShowColors = Colors_Auto;
3732 else
3733 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3734 << ("-fdiagnostics-color=" + value).str();
3735 }
3736 }
3737 if (ShowColors == Colors_On ||
3738 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003739 CmdArgs.push_back("-fcolor-diagnostics");
3740
Nico Rieck7857d462013-09-11 00:38:02 +00003741 if (Args.hasArg(options::OPT_fansi_escape_codes))
3742 CmdArgs.push_back("-fansi-escape-codes");
3743
Daniel Dunbardb097022009-06-08 21:13:54 +00003744 if (!Args.hasFlag(options::OPT_fshow_source_location,
3745 options::OPT_fno_show_source_location))
3746 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003747
Douglas Gregor643c9222011-05-21 17:07:29 +00003748 if (!Args.hasFlag(options::OPT_fshow_column,
3749 options::OPT_fno_show_column,
3750 true))
3751 CmdArgs.push_back("-fno-show-column");
3752
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003753 if (!Args.hasFlag(options::OPT_fspell_checking,
3754 options::OPT_fno_spell_checking))
3755 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003756
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003757
Chad Rosierc8e56e82012-12-05 21:08:21 +00003758 // -fno-asm-blocks is default.
3759 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3760 false))
3761 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003762
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003763 // Enable vectorization per default according to the optimization level
3764 // selected. For optimization levels that want vectorization we use the alias
3765 // option to simplify the hasFlag logic.
3766 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3767 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003768 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003769 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003770 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003771 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003772
Rafael Espindolaf818ef42013-08-01 23:56:42 +00003773 // -fslp-vectorize is default.
3774 if (Args.hasFlag(options::OPT_fslp_vectorize,
3775 options::OPT_fno_slp_vectorize, true))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00003776 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00003777
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003778 // -fno-slp-vectorize-aggressive is default.
3779 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003780 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003781 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003782
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00003783 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3784 A->render(Args, CmdArgs);
3785
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003786 // -fdollars-in-identifiers default varies depending on platform and
3787 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003788 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003789 options::OPT_fno_dollars_in_identifiers)) {
3790 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003791 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003792 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003793 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003794 }
3795
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003796 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3797 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003798 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003799 options::OPT_fno_unit_at_a_time)) {
3800 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003801 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003802 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003803
Eli Friedman055c9702011-11-02 01:53:16 +00003804 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3805 options::OPT_fno_apple_pragma_pack, false))
3806 CmdArgs.push_back("-fapple-pragma-pack");
3807
Eli Benderskyc95cfe82013-07-24 18:20:14 +00003808 // le32-specific flags:
3809 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3810 // by default.
3811 if (getToolChain().getArch() == llvm::Triple::le32) {
3812 CmdArgs.push_back("-fno-math-builtin");
3813 }
3814
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003815 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003816 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003817 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003818#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00003819 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003820 (getToolChain().getArch() == llvm::Triple::arm ||
3821 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003822 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3823 CmdArgs.push_back("-fno-builtin-strcat");
3824 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3825 CmdArgs.push_back("-fno-builtin-strcpy");
3826 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003827#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003828
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003829 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00003830 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003831 options::OPT_traditional_cpp)) {
3832 if (isa<PreprocessJobAction>(JA))
3833 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003834 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003835 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003836 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003837
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003838 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00003839 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003840
3841 // Handle serialized diagnostics.
3842 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3843 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003844 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003845 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003846
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003847 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3848 CmdArgs.push_back("-fretain-comments-from-system-headers");
3849
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003850 // Forward -fcomment-block-commands to -cc1.
3851 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00003852 // Forward -fparse-all-comments to -cc1.
3853 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003854
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003855 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3856 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003857 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003858 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3859 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003860 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003861
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003862 // We translate this by hand to the -cc1 argument, since nightly test uses
3863 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003864 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003865 CmdArgs.push_back("-disable-llvm-optzns");
3866 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003867 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003868 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003869
Daniel Dunbard67a3222009-03-30 06:36:42 +00003870 if (Output.getType() == types::TY_Dependencies) {
3871 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003872 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003873 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003874 CmdArgs.push_back(Output.getFilename());
3875 } else {
3876 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003877 }
3878
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003879 for (InputInfoList::const_iterator
3880 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3881 const InputInfo &II = *it;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00003882
3883 addDashXForInput(Args, II, CmdArgs);
3884
Daniel Dunbarb440f562010-08-02 02:38:21 +00003885 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003886 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003887 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003888 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003889 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003890
Chris Lattnere9d7d782009-11-03 19:50:27 +00003891 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3892
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003893 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003894
3895 // Optionally embed the -cc1 level arguments into the debug info, for build
3896 // analysis.
3897 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003898 ArgStringList OriginalArgs;
3899 for (ArgList::const_iterator it = Args.begin(),
3900 ie = Args.end(); it != ie; ++it)
3901 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003902
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003903 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003904 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003905 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003906 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003907 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003908 }
3909 CmdArgs.push_back("-dwarf-debug-flags");
3910 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3911 }
3912
Eric Christopherd3804002013-02-22 20:12:52 +00003913 // Add the split debug info name to the command lines here so we
3914 // can propagate it to the backend.
3915 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003916 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00003917 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00003918 const char *SplitDwarfOut;
3919 if (SplitDwarf) {
3920 CmdArgs.push_back("-split-dwarf-file");
3921 SplitDwarfOut = SplitDebugName(Args, Inputs);
3922 CmdArgs.push_back(SplitDwarfOut);
3923 }
3924
3925 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00003926 if (Args.hasArg(options::OPT__SLASH_fallback) &&
3927 Output.getType() == types::TY_Object) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00003928 tools::visualstudio::Compile CL(getToolChain());
3929 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3930 LinkingOutput);
3931 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3932 } else {
3933 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3934 }
3935
Daniel Dunbar17731772009-03-23 19:03:36 +00003936
Eric Christopherf1545832013-02-22 23:50:16 +00003937 // Handle the debug info splitting at object creation time if we're
3938 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00003939 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00003940 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00003941 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00003942
Roman Divacky178e01602011-02-10 16:52:03 +00003943 if (Arg *A = Args.getLastArg(options::OPT_pg))
3944 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003945 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003946 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003947
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003948 // Claim some arguments which clang supports automatically.
3949
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003950 // -fpch-preprocess is used with gcc to add a special marker in the output to
3951 // include the PCH file. Clang's PTH solution is completely transparent, so we
3952 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003953 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003954
Daniel Dunbar17731772009-03-23 19:03:36 +00003955 // Claim some arguments which clang doesn't support, but we don't
3956 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003957 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3958 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003959
Rafael Espindolab0092d72013-09-04 19:37:35 +00003960 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00003961 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003962}
3963
John McCall5fb5df92012-06-20 06:18:46 +00003964/// Add options related to the Objective-C runtime/ABI.
3965///
3966/// Returns true if the runtime is non-fragile.
3967ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3968 ArgStringList &cmdArgs,
3969 RewriteKind rewriteKind) const {
3970 // Look for the controlling runtime option.
3971 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3972 options::OPT_fgnu_runtime,
3973 options::OPT_fobjc_runtime_EQ);
3974
3975 // Just forward -fobjc-runtime= to the frontend. This supercedes
3976 // options about fragility.
3977 if (runtimeArg &&
3978 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3979 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003980 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003981 if (runtime.tryParse(value)) {
3982 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3983 << value;
3984 }
3985
3986 runtimeArg->render(args, cmdArgs);
3987 return runtime;
3988 }
3989
3990 // Otherwise, we'll need the ABI "version". Version numbers are
3991 // slightly confusing for historical reasons:
3992 // 1 - Traditional "fragile" ABI
3993 // 2 - Non-fragile ABI, version 1
3994 // 3 - Non-fragile ABI, version 2
3995 unsigned objcABIVersion = 1;
3996 // If -fobjc-abi-version= is present, use that to set the version.
3997 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003998 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003999 if (value == "1")
4000 objcABIVersion = 1;
4001 else if (value == "2")
4002 objcABIVersion = 2;
4003 else if (value == "3")
4004 objcABIVersion = 3;
4005 else
4006 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4007 << value;
4008 } else {
4009 // Otherwise, determine if we are using the non-fragile ABI.
4010 bool nonFragileABIIsDefault =
4011 (rewriteKind == RK_NonFragile ||
4012 (rewriteKind == RK_None &&
4013 getToolChain().IsObjCNonFragileABIDefault()));
4014 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4015 options::OPT_fno_objc_nonfragile_abi,
4016 nonFragileABIIsDefault)) {
4017 // Determine the non-fragile ABI version to use.
4018#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4019 unsigned nonFragileABIVersion = 1;
4020#else
4021 unsigned nonFragileABIVersion = 2;
4022#endif
4023
4024 if (Arg *abiArg = args.getLastArg(
4025 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004026 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004027 if (value == "1")
4028 nonFragileABIVersion = 1;
4029 else if (value == "2")
4030 nonFragileABIVersion = 2;
4031 else
4032 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4033 << value;
4034 }
4035
4036 objcABIVersion = 1 + nonFragileABIVersion;
4037 } else {
4038 objcABIVersion = 1;
4039 }
4040 }
4041
4042 // We don't actually care about the ABI version other than whether
4043 // it's non-fragile.
4044 bool isNonFragile = objcABIVersion != 1;
4045
4046 // If we have no runtime argument, ask the toolchain for its default runtime.
4047 // However, the rewriter only really supports the Mac runtime, so assume that.
4048 ObjCRuntime runtime;
4049 if (!runtimeArg) {
4050 switch (rewriteKind) {
4051 case RK_None:
4052 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4053 break;
4054 case RK_Fragile:
4055 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4056 break;
4057 case RK_NonFragile:
4058 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4059 break;
4060 }
4061
4062 // -fnext-runtime
4063 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4064 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004065 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004066 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4067
4068 // Otherwise, build for a generic macosx port.
4069 } else {
4070 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4071 }
4072
4073 // -fgnu-runtime
4074 } else {
4075 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004076 // Legacy behaviour is to target the gnustep runtime if we are i
4077 // non-fragile mode or the GCC runtime in fragile mode.
4078 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004079 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004080 else
4081 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004082 }
4083
4084 cmdArgs.push_back(args.MakeArgString(
4085 "-fobjc-runtime=" + runtime.getAsString()));
4086 return runtime;
4087}
4088
Hans Wennborg75958c42013-08-08 00:17:41 +00004089void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4090 unsigned RTOptionID = options::OPT__SLASH_MT;
4091
Hans Wennborgf1a74252013-09-10 20:18:04 +00004092 if (Args.hasArg(options::OPT__SLASH_LDd))
4093 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4094 // but defining _DEBUG is sticky.
4095 RTOptionID = options::OPT__SLASH_MTd;
4096
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004097 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004098 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004099
Hans Wennborg75958c42013-08-08 00:17:41 +00004100 switch(RTOptionID) {
4101 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004102 if (Args.hasArg(options::OPT__SLASH_LDd))
4103 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004104 CmdArgs.push_back("-D_MT");
4105 CmdArgs.push_back("-D_DLL");
4106 CmdArgs.push_back("--dependent-lib=msvcrt");
4107 break;
4108 case options::OPT__SLASH_MDd:
4109 CmdArgs.push_back("-D_DEBUG");
4110 CmdArgs.push_back("-D_MT");
4111 CmdArgs.push_back("-D_DLL");
4112 CmdArgs.push_back("--dependent-lib=msvcrtd");
4113 break;
4114 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004115 if (Args.hasArg(options::OPT__SLASH_LDd))
4116 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004117 CmdArgs.push_back("-D_MT");
4118 CmdArgs.push_back("--dependent-lib=libcmt");
4119 break;
4120 case options::OPT__SLASH_MTd:
4121 CmdArgs.push_back("-D_DEBUG");
4122 CmdArgs.push_back("-D_MT");
4123 CmdArgs.push_back("--dependent-lib=libcmtd");
4124 break;
4125 default:
4126 llvm_unreachable("Unexpected option ID.");
4127 }
4128
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004129 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4130 // users want. The /Za flag to cl.exe turns this off, but it's not
4131 // implemented in clang.
4132 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004133
Hans Wennborg0fd62072013-08-09 00:32:23 +00004134 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4135 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004136
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004137 // RTTI is currently not supported, so disable it by default.
4138 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4139 CmdArgs.push_back("-fno-rtti");
4140
Hans Wennborgd8d49ba2014-03-25 17:50:25 +00004141 // Let -ffunction-sections imply -fdata-sections.
4142 if (Arg * A = Args.getLastArg(options::OPT_ffunction_sections,
4143 options::OPT_fno_function_sections))
4144 if (A->getOption().matches(options::OPT_ffunction_sections))
4145 CmdArgs.push_back("-fdata-sections");
4146
David Majnemer86c318f2014-02-11 21:05:00 +00004147 const Driver &D = getToolChain().getDriver();
4148 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4149 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4150 if (MostGeneralArg && BestCaseArg)
4151 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4152 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4153
4154 if (MostGeneralArg) {
4155 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4156 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4157 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4158
4159 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4160 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4161 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4162 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4163 << FirstConflict->getAsString(Args)
4164 << SecondConflict->getAsString(Args);
4165
4166 if (SingleArg)
4167 CmdArgs.push_back("-fms-memptr-rep=single");
4168 else if (MultipleArg)
4169 CmdArgs.push_back("-fms-memptr-rep=multiple");
4170 else
4171 CmdArgs.push_back("-fms-memptr-rep=virtual");
4172 }
4173
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004174 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4175 A->render(Args, CmdArgs);
4176
Hans Wennborg81f74482013-09-10 01:07:07 +00004177 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4178 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004179 if (Args.hasArg(options::OPT__SLASH_fallback))
4180 CmdArgs.push_back("msvc-fallback");
4181 else
4182 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004183 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004184}
4185
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004186void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004187 const InputInfo &Output,
4188 const InputInfoList &Inputs,
4189 const ArgList &Args,
4190 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004191 ArgStringList CmdArgs;
4192
4193 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4194 const InputInfo &Input = Inputs[0];
4195
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004196 // Don't warn about "clang -w -c foo.s"
4197 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004198 // and "clang -emit-llvm -c foo.s"
4199 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004200
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004201 // Invoke ourselves in -cc1as mode.
4202 //
4203 // FIXME: Implement custom jobs for internal actions.
4204 CmdArgs.push_back("-cc1as");
4205
4206 // Add the "effective" target triple.
4207 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004208 std::string TripleStr =
4209 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004210 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4211
4212 // Set the output mode, we currently only expect to be used as a real
4213 // assembler.
4214 CmdArgs.push_back("-filetype");
4215 CmdArgs.push_back("obj");
4216
Eric Christopher45f2e712012-12-18 00:31:10 +00004217 // Set the main file name, so that debug info works even with
4218 // -save-temps or preprocessed assembly.
4219 CmdArgs.push_back("-main-file-name");
4220 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4221
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004222 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004223 const llvm::Triple &Triple = getToolChain().getTriple();
4224 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004225 if (!CPU.empty()) {
4226 CmdArgs.push_back("-target-cpu");
4227 CmdArgs.push_back(Args.MakeArgString(CPU));
4228 }
4229
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004230 // Add the target features
4231 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004232 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004233
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004234 // Ignore explicit -force_cpusubtype_ALL option.
4235 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004236
Eric Christopherfc3ee562012-01-10 00:38:01 +00004237 // Determine the original source input.
4238 const Action *SourceAction = &JA;
4239 while (SourceAction->getKind() != Action::InputClass) {
4240 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4241 SourceAction = SourceAction->getInputs()[0];
4242 }
4243
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004244 // Forward -g and handle debug info related flags, assuming we are dealing
4245 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004246 if (SourceAction->getType() == types::TY_Asm ||
4247 SourceAction->getType() == types::TY_PP_Asm) {
4248 Args.ClaimAllArgs(options::OPT_g_Group);
4249 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4250 if (!A->getOption().matches(options::OPT_g0))
4251 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004252
4253 // Add the -fdebug-compilation-dir flag if needed.
4254 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004255
4256 // Set the AT_producer to the clang version when using the integrated
4257 // assembler on assembly source files.
4258 CmdArgs.push_back("-dwarf-debug-producer");
4259 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004260 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004261
4262 // Optionally embed the -cc1as level arguments into the debug info, for build
4263 // analysis.
4264 if (getToolChain().UseDwarfDebugFlags()) {
4265 ArgStringList OriginalArgs;
4266 for (ArgList::const_iterator it = Args.begin(),
4267 ie = Args.end(); it != ie; ++it)
4268 (*it)->render(Args, OriginalArgs);
4269
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004270 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004271 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4272 Flags += Exec;
4273 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4274 Flags += " ";
4275 Flags += OriginalArgs[i];
4276 }
4277 CmdArgs.push_back("-dwarf-debug-flags");
4278 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4279 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004280
4281 // FIXME: Add -static support, once we have it.
4282
David Blaikie372d9502014-01-17 03:17:40 +00004283 // Consume all the warning flags. Usually this would be handled more
4284 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4285 // doesn't handle that so rather than warning about unused flags that are
4286 // actually used, we'll lie by omission instead.
4287 // FIXME: Stop lying and consume only the appropriate driver flags
4288 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4289 ie = Args.filtered_end();
4290 it != ie; ++it)
4291 (*it)->claim();
4292
David Blaikie9260ed62013-07-25 21:19:01 +00004293 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4294 getToolChain().getDriver());
4295
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004296 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004297
4298 assert(Output.isFilename() && "Unexpected lipo output.");
4299 CmdArgs.push_back("-o");
4300 CmdArgs.push_back(Output.getFilename());
4301
Daniel Dunbarb440f562010-08-02 02:38:21 +00004302 assert(Input.isFilename() && "Invalid input.");
4303 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004304
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004305 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004306 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004307
4308 // Handle the debug info splitting at object creation time if we're
4309 // creating an object.
4310 // TODO: Currently only works on linux with newer objcopy.
4311 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004312 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004313 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4314 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004315}
4316
Daniel Dunbara3246a02009-03-18 08:07:30 +00004317void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004318 const InputInfo &Output,
4319 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004320 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004321 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004322 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004323 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004324
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004325 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004326 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004327 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004328 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004329 // Don't forward any -g arguments to assembly steps.
4330 if (isa<AssembleJobAction>(JA) &&
4331 A->getOption().matches(options::OPT_g_Group))
4332 continue;
4333
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004334 // Don't forward any -W arguments to assembly and link steps.
4335 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4336 A->getOption().matches(options::OPT_W_Group))
4337 continue;
4338
Daniel Dunbar2da02722009-03-19 07:55:12 +00004339 // It is unfortunate that we have to claim here, as this means
4340 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004341 // platforms using a generic gcc, even if we are just using gcc
4342 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004343 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004344 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004345 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004346 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004347
Daniel Dunbar4e295052010-01-25 22:35:08 +00004348 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004349
4350 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004351 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004352 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004353 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004354
4355 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004356 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004357 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004358 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004359 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004360 else if (Arch == llvm::Triple::ppc64le)
4361 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004362 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004363 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004364 }
4365
Daniel Dunbar5716d872009-05-02 21:41:52 +00004366 // Try to force gcc to match the tool chain we want, if we recognize
4367 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004368 //
4369 // FIXME: The triple class should directly provide the information we want
4370 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004371 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004372 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004373 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4374 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004375 CmdArgs.push_back("-m64");
4376
Daniel Dunbarb440f562010-08-02 02:38:21 +00004377 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004378 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004379 CmdArgs.push_back(Output.getFilename());
4380 } else {
4381 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004382 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004383 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004384
Tony Linthicum76329bf2011-12-12 21:14:55 +00004385 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4386 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004387
4388 // Only pass -x if gcc will understand it; otherwise hope gcc
4389 // understands the suffix correctly. The main use case this would go
4390 // wrong in is for linker inputs if they happened to have an odd
4391 // suffix; really the only way to get this to happen is a command
4392 // like '-x foobar a.c' which will treat a.c like a linker input.
4393 //
4394 // FIXME: For the linker case specifically, can we safely convert
4395 // inputs into '-Wl,' options?
4396 for (InputInfoList::const_iterator
4397 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4398 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004399
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004400 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004401 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4402 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004403 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004404 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004405 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004406 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004407 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004408 else if (II.getType() == types::TY_ModuleFile)
4409 D.Diag(diag::err_drv_no_module_support)
4410 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004411
Daniel Dunbara3246a02009-03-18 08:07:30 +00004412 if (types::canTypeBeUserSpecified(II.getType())) {
4413 CmdArgs.push_back("-x");
4414 CmdArgs.push_back(types::getTypeName(II.getType()));
4415 }
4416
Daniel Dunbarb440f562010-08-02 02:38:21 +00004417 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004418 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004419 else {
4420 const Arg &A = II.getInputArg();
4421
4422 // Reverse translate some rewritten options.
4423 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4424 CmdArgs.push_back("-lstdc++");
4425 continue;
4426 }
4427
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004428 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004429 A.render(Args, CmdArgs);
4430 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004431 }
4432
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004433 const std::string customGCCName = D.getCCCGenericGCCName();
4434 const char *GCCName;
4435 if (!customGCCName.empty())
4436 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004437 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004438 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004439 } else
4440 GCCName = "gcc";
4441
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004442 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004443 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004444 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004445}
4446
Daniel Dunbar4e295052010-01-25 22:35:08 +00004447void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4448 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004449 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004450}
4451
Daniel Dunbar4e295052010-01-25 22:35:08 +00004452void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4453 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004454 const Driver &D = getToolChain().getDriver();
4455
Daniel Dunbar4e295052010-01-25 22:35:08 +00004456 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004457 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4458 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004459 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004460 else {
4461 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004462 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004463 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004464
Daniel Dunbar4e295052010-01-25 22:35:08 +00004465 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004466 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004467}
4468
Daniel Dunbar4e295052010-01-25 22:35:08 +00004469void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4470 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004471 // The types are (hopefully) good enough.
4472}
4473
Tony Linthicum76329bf2011-12-12 21:14:55 +00004474// Hexagon tools start.
4475void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4476 ArgStringList &CmdArgs) const {
4477
4478}
4479void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4480 const InputInfo &Output,
4481 const InputInfoList &Inputs,
4482 const ArgList &Args,
4483 const char *LinkingOutput) const {
4484
4485 const Driver &D = getToolChain().getDriver();
4486 ArgStringList CmdArgs;
4487
4488 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004489 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004490 CmdArgs.push_back(Args.MakeArgString(MarchString));
4491
4492 RenderExtraToolArgs(JA, CmdArgs);
4493
4494 if (Output.isFilename()) {
4495 CmdArgs.push_back("-o");
4496 CmdArgs.push_back(Output.getFilename());
4497 } else {
4498 assert(Output.isNothing() && "Unexpected output");
4499 CmdArgs.push_back("-fsyntax-only");
4500 }
4501
Matthew Curtise8f80a12012-12-06 17:49:03 +00004502 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4503 if (!SmallDataThreshold.empty())
4504 CmdArgs.push_back(
4505 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004506
Matthew Curtise5df3812012-12-07 17:23:04 +00004507 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4508 options::OPT_Xassembler);
4509
Tony Linthicum76329bf2011-12-12 21:14:55 +00004510 // Only pass -x if gcc will understand it; otherwise hope gcc
4511 // understands the suffix correctly. The main use case this would go
4512 // wrong in is for linker inputs if they happened to have an odd
4513 // suffix; really the only way to get this to happen is a command
4514 // like '-x foobar a.c' which will treat a.c like a linker input.
4515 //
4516 // FIXME: For the linker case specifically, can we safely convert
4517 // inputs into '-Wl,' options?
4518 for (InputInfoList::const_iterator
4519 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4520 const InputInfo &II = *it;
4521
4522 // Don't try to pass LLVM or AST inputs to a generic gcc.
4523 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4524 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4525 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4526 << getToolChain().getTripleString();
4527 else if (II.getType() == types::TY_AST)
4528 D.Diag(clang::diag::err_drv_no_ast_support)
4529 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004530 else if (II.getType() == types::TY_ModuleFile)
4531 D.Diag(diag::err_drv_no_module_support)
4532 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004533
4534 if (II.isFilename())
4535 CmdArgs.push_back(II.getFilename());
4536 else
4537 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4538 II.getInputArg().render(Args, CmdArgs);
4539 }
4540
4541 const char *GCCName = "hexagon-as";
4542 const char *Exec =
4543 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4544 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4545
4546}
4547void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4548 ArgStringList &CmdArgs) const {
4549 // The types are (hopefully) good enough.
4550}
4551
4552void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4553 const InputInfo &Output,
4554 const InputInfoList &Inputs,
4555 const ArgList &Args,
4556 const char *LinkingOutput) const {
4557
Matthew Curtise689b052012-12-06 15:46:07 +00004558 const toolchains::Hexagon_TC& ToolChain =
4559 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4560 const Driver &D = ToolChain.getDriver();
4561
Tony Linthicum76329bf2011-12-12 21:14:55 +00004562 ArgStringList CmdArgs;
4563
Matthew Curtise689b052012-12-06 15:46:07 +00004564 //----------------------------------------------------------------------------
4565 //
4566 //----------------------------------------------------------------------------
4567 bool hasStaticArg = Args.hasArg(options::OPT_static);
4568 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004569 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004570 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4571 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4572 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4573 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004574
Matthew Curtise689b052012-12-06 15:46:07 +00004575 //----------------------------------------------------------------------------
4576 // Silence warnings for various options
4577 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004578
Matthew Curtise689b052012-12-06 15:46:07 +00004579 Args.ClaimAllArgs(options::OPT_g_Group);
4580 Args.ClaimAllArgs(options::OPT_emit_llvm);
4581 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4582 // handled somewhere else.
4583 Args.ClaimAllArgs(options::OPT_static_libgcc);
4584
4585 //----------------------------------------------------------------------------
4586 //
4587 //----------------------------------------------------------------------------
4588 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4589 e = ToolChain.ExtraOpts.end();
4590 i != e; ++i)
4591 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004592
Matthew Curtisf10a5952012-12-06 14:16:43 +00004593 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4594 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004595
Matthew Curtise689b052012-12-06 15:46:07 +00004596 if (buildingLib) {
4597 CmdArgs.push_back("-shared");
4598 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4599 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004600 }
4601
Matthew Curtise689b052012-12-06 15:46:07 +00004602 if (hasStaticArg)
4603 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004604
Matthew Curtise8f80a12012-12-06 17:49:03 +00004605 if (buildPIE && !buildingLib)
4606 CmdArgs.push_back("-pie");
4607
4608 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4609 if (!SmallDataThreshold.empty()) {
4610 CmdArgs.push_back(
4611 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4612 }
4613
Matthew Curtise689b052012-12-06 15:46:07 +00004614 //----------------------------------------------------------------------------
4615 //
4616 //----------------------------------------------------------------------------
4617 CmdArgs.push_back("-o");
4618 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004619
Matthew Curtise689b052012-12-06 15:46:07 +00004620 const std::string MarchSuffix = "/" + MarchString;
4621 const std::string G0Suffix = "/G0";
4622 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4623 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4624 + "/";
4625 const std::string StartFilesDir = RootDir
4626 + "hexagon/lib"
4627 + (buildingLib
4628 ? MarchG0Suffix : MarchSuffix);
4629
4630 //----------------------------------------------------------------------------
4631 // moslib
4632 //----------------------------------------------------------------------------
4633 std::vector<std::string> oslibs;
4634 bool hasStandalone= false;
4635
4636 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4637 ie = Args.filtered_end(); it != ie; ++it) {
4638 (*it)->claim();
4639 oslibs.push_back((*it)->getValue());
4640 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004641 }
Matthew Curtise689b052012-12-06 15:46:07 +00004642 if (oslibs.empty()) {
4643 oslibs.push_back("standalone");
4644 hasStandalone = true;
4645 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004646
Matthew Curtise689b052012-12-06 15:46:07 +00004647 //----------------------------------------------------------------------------
4648 // Start Files
4649 //----------------------------------------------------------------------------
4650 if (incStdLib && incStartFiles) {
4651
4652 if (!buildingLib) {
4653 if (hasStandalone) {
4654 CmdArgs.push_back(
4655 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4656 }
4657 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4658 }
4659 std::string initObj = useShared ? "/initS.o" : "/init.o";
4660 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4661 }
4662
4663 //----------------------------------------------------------------------------
4664 // Library Search Paths
4665 //----------------------------------------------------------------------------
4666 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4667 for (ToolChain::path_list::const_iterator
4668 i = LibPaths.begin(),
4669 e = LibPaths.end();
4670 i != e;
4671 ++i)
4672 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4673
4674 //----------------------------------------------------------------------------
4675 //
4676 //----------------------------------------------------------------------------
4677 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4678 Args.AddAllArgs(CmdArgs, options::OPT_e);
4679 Args.AddAllArgs(CmdArgs, options::OPT_s);
4680 Args.AddAllArgs(CmdArgs, options::OPT_t);
4681 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4682
4683 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4684
4685 //----------------------------------------------------------------------------
4686 // Libraries
4687 //----------------------------------------------------------------------------
4688 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004689 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004690 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4691 CmdArgs.push_back("-lm");
4692 }
4693
4694 CmdArgs.push_back("--start-group");
4695
4696 if (!buildingLib) {
4697 for(std::vector<std::string>::iterator i = oslibs.begin(),
4698 e = oslibs.end(); i != e; ++i)
4699 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4700 CmdArgs.push_back("-lc");
4701 }
4702 CmdArgs.push_back("-lgcc");
4703
4704 CmdArgs.push_back("--end-group");
4705 }
4706
4707 //----------------------------------------------------------------------------
4708 // End files
4709 //----------------------------------------------------------------------------
4710 if (incStdLib && incStartFiles) {
4711 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4712 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4713 }
4714
4715 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004716 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004717}
4718// Hexagon tools end.
4719
Bernard Ogden31561762013-12-12 13:27:11 +00004720/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4721//
4722// FIXME: tblgen this.
4723const char *arm::getARMCPUForMArch(const ArgList &Args,
4724 const llvm::Triple &Triple) {
4725 StringRef MArch;
4726 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4727 // Otherwise, if we have -march= choose the base CPU for that arch.
4728 MArch = A->getValue();
4729 } else {
4730 // Otherwise, use the Arch from the triple.
4731 MArch = Triple.getArchName();
4732 }
4733
4734 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004735 if (MArch == "native") {
4736 std::string CPU = llvm::sys::getHostCPUName();
4737 if (CPU != "generic") {
4738 // Translate the native cpu into the architecture. The switch below will
4739 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004740 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004741 }
4742 }
4743
4744 if (Triple.getOS() == llvm::Triple::NetBSD) {
4745 if (MArch == "armv6")
4746 return "arm1176jzf-s";
4747 }
4748
4749 const char *result = llvm::StringSwitch<const char *>(MArch)
4750 .Cases("armv2", "armv2a","arm2")
4751 .Case("armv3", "arm6")
4752 .Case("armv3m", "arm7m")
4753 .Case("armv4", "strongarm")
4754 .Case("armv4t", "arm7tdmi")
4755 .Case("thumbv4t", "arm7tdmi")
4756 .Cases("armv5", "armv5t", "arm10tdmi")
4757 .Cases("thumbv5", "thumbv5t", "arm10tdmi")
4758 .Cases("armv5e", "armv5te", "arm1022e")
4759 .Cases("thumbv5e", "thumbv5te", "arm1022e")
4760 .Case("armv5tej", "arm926ej-s")
4761 .Case("thumbv5tej", "arm926ej-s")
4762 .Cases("armv6", "armv6k", "arm1136jf-s")
4763 .Cases("thumbv6", "thumbv6k", "arm1136jf-s")
4764 .Case("armv6j", "arm1136j-s")
4765 .Case("thumbv6j", "arm1136j-s")
4766 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
4767 .Cases("thumbv6z", "thumbv6zk", "arm1176jzf-s")
4768 .Case("armv6t2", "arm1156t2-s")
4769 .Case("thumbv6t2", "arm1156t2-s")
4770 .Cases("armv6m", "armv6-m", "cortex-m0")
4771 .Case("thumbv6m", "cortex-m0")
4772 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
4773 .Cases("thumbv7", "thumbv7a", "cortex-a8")
4774 .Cases("armv7l", "armv7-l", "cortex-a8")
Bernard Ogden31561762013-12-12 13:27:11 +00004775 .Cases("armv7s", "armv7-s", "swift")
4776 .Cases("armv7r", "armv7-r", "cortex-r4")
4777 .Case("thumbv7r", "cortex-r4")
4778 .Cases("armv7m", "armv7-m", "cortex-m3")
4779 .Case("thumbv7m", "cortex-m3")
4780 .Cases("armv7em", "armv7e-m", "cortex-m4")
4781 .Cases("thumbv7em", "thumbv7e-m", "cortex-m4")
4782 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
4783 .Cases("thumbv8", "thumbv8a", "cortex-a53")
4784 .Case("ep9312", "ep9312")
4785 .Case("iwmmxt", "iwmmxt")
4786 .Case("xscale", "xscale")
4787 // If all else failed, return the most base CPU with thumb interworking
4788 // supported by LLVM.
4789 .Default(0);
4790
4791 if (result)
4792 return result;
4793
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00004794 switch (Triple.getOS()) {
4795 case llvm::Triple::NetBSD:
4796 switch (Triple.getEnvironment()) {
4797 case llvm::Triple::GNUEABIHF:
4798 case llvm::Triple::GNUEABI:
4799 case llvm::Triple::EABIHF:
4800 case llvm::Triple::EABI:
4801 return "arm926ej-s";
4802 default:
4803 return "strongarm";
4804 }
4805 default:
4806 switch (Triple.getEnvironment()) {
4807 case llvm::Triple::EABIHF:
4808 case llvm::Triple::GNUEABIHF:
4809 return "arm1176jzf-s";
4810 default:
4811 return "arm7tdmi";
4812 }
4813 }
Bernard Ogden31561762013-12-12 13:27:11 +00004814}
4815
4816/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00004817StringRef arm::getARMTargetCPU(const ArgList &Args,
4818 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00004819 // FIXME: Warn on inconsistent use of -mcpu and -march.
4820 // If we have -mcpu=, use that.
4821 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
4822 StringRef MCPU = A->getValue();
4823 // Handle -mcpu=native.
4824 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00004825 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00004826 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00004827 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00004828 }
4829
4830 return getARMCPUForMArch(Args, Triple);
4831}
4832
4833/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
4834/// CPU.
4835//
4836// FIXME: This is redundant with -mcpu, why does LLVM use this.
4837// FIXME: tblgen this, or kill it!
4838const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
4839 return llvm::StringSwitch<const char *>(CPU)
4840 .Case("strongarm", "v4")
4841 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
4842 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
4843 .Cases("arm920", "arm920t", "arm922t", "v4t")
4844 .Cases("arm940t", "ep9312","v4t")
4845 .Cases("arm10tdmi", "arm1020t", "v5")
4846 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
4847 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
4848 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
4849 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
4850 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
4851 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00004852 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00004853 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
4854 .Cases("cortex-r4", "cortex-r5", "v7r")
4855 .Case("cortex-m0", "v6m")
4856 .Case("cortex-m3", "v7m")
4857 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00004858 .Case("swift", "v7s")
4859 .Cases("cortex-a53", "cortex-a57", "v8")
4860 .Default("");
4861}
4862
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004863bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
4864 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
4865 return A && (A->getValue() == StringRef(Value));
4866}
4867
Tim Northover157d9112014-01-16 08:48:16 +00004868llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004869 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4870 // archs which Darwin doesn't use.
4871
4872 // The matching this routine does is fairly pointless, since it is neither the
4873 // complete architecture list, nor a reasonable subset. The problem is that
4874 // historically the driver driver accepts this and also ties its -march=
4875 // handling to the architecture name, so we need to be careful before removing
4876 // support for it.
4877
4878 // This code must be kept in sync with Clang's Darwin specific argument
4879 // translation.
4880
4881 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4882 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4883 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4884 .Case("ppc64", llvm::Triple::ppc64)
4885 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4886 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4887 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00004888 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004889 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00004890 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00004891 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00004892 .Cases("armv7s", "xscale", llvm::Triple::arm)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004893 .Case("r600", llvm::Triple::r600)
4894 .Case("nvptx", llvm::Triple::nvptx)
4895 .Case("nvptx64", llvm::Triple::nvptx64)
4896 .Case("amdil", llvm::Triple::amdil)
4897 .Case("spir", llvm::Triple::spir)
4898 .Default(llvm::Triple::UnknownArch);
4899}
Tony Linthicum76329bf2011-12-12 21:14:55 +00004900
Tim Northover157d9112014-01-16 08:48:16 +00004901void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
4902 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
4903 T.setArch(Arch);
4904
4905 if (Str == "x86_64h")
4906 T.setArchName(Str);
4907 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
4908 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00004909 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00004910 }
4911}
4912
Bob Wilsondecc03e2012-11-23 06:14:39 +00004913const char *Clang::getBaseInputName(const ArgList &Args,
4914 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00004915 return Args.MakeArgString(
4916 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004917}
4918
Bob Wilsondecc03e2012-11-23 06:14:39 +00004919const char *Clang::getBaseInputStem(const ArgList &Args,
4920 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004921 const char *Str = getBaseInputName(Args, Inputs);
4922
Chris Lattner906bb902011-01-16 08:14:11 +00004923 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004924 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004925
4926 return Str;
4927}
4928
Bob Wilsondecc03e2012-11-23 06:14:39 +00004929const char *Clang::getDependencyFileName(const ArgList &Args,
4930 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004931 // FIXME: Think about this more.
4932 std::string Res;
4933
4934 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004935 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004936 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004937 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00004938 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004939 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004940 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004941}
4942
Daniel Dunbarbe220842009-03-20 16:06:39 +00004943void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004944 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004945 const InputInfoList &Inputs,
4946 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00004947 const char *LinkingOutput) const {
4948 ArgStringList CmdArgs;
4949
4950 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4951 const InputInfo &Input = Inputs[0];
4952
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004953 // Determine the original source input.
4954 const Action *SourceAction = &JA;
4955 while (SourceAction->getKind() != Action::InputClass) {
4956 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4957 SourceAction = SourceAction->getInputs()[0];
4958 }
4959
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004960 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00004961 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00004962 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
4963 // FIXME: at run-time detect assembler capabilities or rely on version
4964 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004965 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00004966 const llvm::Triple &T(getToolChain().getTriple());
4967 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00004968 CmdArgs.push_back("-Q");
4969 }
Kevin Enderby319baa42013-11-18 23:30:29 +00004970
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004971 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00004972 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004973 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004974 if (Args.hasArg(options::OPT_gstabs))
4975 CmdArgs.push_back("--gstabs");
4976 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00004977 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004978 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004979
Daniel Dunbarbe220842009-03-20 16:06:39 +00004980 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00004981 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00004982
Daniel Dunbar6d484762010-07-22 01:47:22 +00004983 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004984 if (getToolChain().getArch() == llvm::Triple::x86 ||
4985 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00004986 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4987 CmdArgs.push_back("-force_cpusubtype_ALL");
4988
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004989 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004990 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00004991 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00004992 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004993 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004994 CmdArgs.push_back("-static");
4995
Daniel Dunbarbe220842009-03-20 16:06:39 +00004996 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4997 options::OPT_Xassembler);
4998
4999 assert(Output.isFilename() && "Unexpected lipo output.");
5000 CmdArgs.push_back("-o");
5001 CmdArgs.push_back(Output.getFilename());
5002
Daniel Dunbarb440f562010-08-02 02:38:21 +00005003 assert(Input.isFilename() && "Invalid input.");
5004 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005005
5006 // asm_final spec is empty.
5007
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005008 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005009 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005010 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005011}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005012
Tim Northover157d9112014-01-16 08:48:16 +00005013void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005014
Tim Northover157d9112014-01-16 08:48:16 +00005015void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5016 ArgStringList &CmdArgs) const {
5017 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005018
Daniel Dunbarc1964212009-03-26 16:23:12 +00005019 // Derived from darwin_arch spec.
5020 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005021 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005022
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005023 // FIXME: Is this needed anymore?
5024 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005025 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005026}
5027
Bill Wendling3b2000f2012-10-02 18:02:50 +00005028bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5029 // We only need to generate a temp path for LTO if we aren't compiling object
5030 // files. When compiling source files, we run 'dsymutil' after linking. We
5031 // don't run 'dsymutil' when compiling object files.
5032 for (InputInfoList::const_iterator
5033 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
5034 if (it->getType() != types::TY_Object)
5035 return true;
5036
5037 return false;
5038}
5039
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005040void darwin::Link::AddLinkArgs(Compilation &C,
5041 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005042 ArgStringList &CmdArgs,
5043 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005044 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005045 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005046
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005047 unsigned Version[3] = { 0, 0, 0 };
5048 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5049 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005050 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005051 Version[1], Version[2], HadExtra) ||
5052 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005053 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005054 << A->getAsString(Args);
5055 }
5056
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005057 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005058 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005059 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5060 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005061
Bob Wilson3d27dad2013-08-02 22:25:34 +00005062 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5063 CmdArgs.push_back("-export_dynamic");
5064
Bill Wendling313b6bf2012-11-16 23:03:00 +00005065 // If we are using LTO, then automatically create a temporary file path for
5066 // the linker to use, so that it's lifetime will extend past a possible
5067 // dsymutil step.
5068 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5069 const char *TmpPath = C.getArgs().MakeArgString(
5070 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5071 C.addTempFile(TmpPath);
5072 CmdArgs.push_back("-object_path_lto");
5073 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005074 }
5075
Daniel Dunbarc1964212009-03-26 16:23:12 +00005076 // Derived from the "link" spec.
5077 Args.AddAllArgs(CmdArgs, options::OPT_static);
5078 if (!Args.hasArg(options::OPT_static))
5079 CmdArgs.push_back("-dynamic");
5080 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5081 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5082 // here. How do we wish to handle such things?
5083 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005084
Daniel Dunbarc1964212009-03-26 16:23:12 +00005085 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005086 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005087 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005088 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005089
5090 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5091 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5092 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5093
5094 Arg *A;
5095 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5096 (A = Args.getLastArg(options::OPT_current__version)) ||
5097 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005098 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005099 << A->getAsString(Args) << "-dynamiclib";
5100
5101 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5102 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5103 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5104 } else {
5105 CmdArgs.push_back("-dylib");
5106
5107 Arg *A;
5108 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5109 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5110 (A = Args.getLastArg(options::OPT_client__name)) ||
5111 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5112 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5113 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005114 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005115 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005116
Daniel Dunbarc1964212009-03-26 16:23:12 +00005117 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5118 "-dylib_compatibility_version");
5119 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5120 "-dylib_current_version");
5121
Tim Northover157d9112014-01-16 08:48:16 +00005122 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005123
5124 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5125 "-dylib_install_name");
5126 }
5127
5128 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5129 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5130 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005131 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005132 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005133 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5134 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5135 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5136 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5137 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5138 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005139 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005140 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5141 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5142 Args.AddAllArgs(CmdArgs, options::OPT_init);
5143
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005144 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005145 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005146
Daniel Dunbarc1964212009-03-26 16:23:12 +00005147 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5148 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5149 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5150 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5151 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005152
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005153 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5154 options::OPT_fno_pie,
5155 options::OPT_fno_PIE)) {
5156 if (A->getOption().matches(options::OPT_fpie) ||
5157 A->getOption().matches(options::OPT_fPIE))
5158 CmdArgs.push_back("-pie");
5159 else
5160 CmdArgs.push_back("-no_pie");
5161 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005162
5163 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5164 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5165 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5166 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5167 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5168 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5169 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5170 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5171 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5172 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5173 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5174 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5175 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5176 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5177 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5178 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005179
Daniel Dunbar84384642011-05-02 21:03:47 +00005180 // Give --sysroot= preference, over the Apple specific behavior to also use
5181 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005182 StringRef sysroot = C.getSysRoot();
5183 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005184 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005185 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005186 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5187 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005188 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005189 }
5190
Daniel Dunbarc1964212009-03-26 16:23:12 +00005191 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5192 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5193 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5194 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5195 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005196 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005197 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5198 Args.AddAllArgs(CmdArgs, options::OPT_y);
5199 Args.AddLastArg(CmdArgs, options::OPT_w);
5200 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5201 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5202 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5203 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5204 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5205 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5206 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5207 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5208 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5209 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5210 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5211 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5212}
5213
Alexey Bataev186b28a2014-03-06 05:43:53 +00005214enum LibOpenMP {
5215 LibUnknown,
5216 LibGOMP,
5217 LibIOMP5
5218};
5219
Daniel Dunbarc1964212009-03-26 16:23:12 +00005220void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005221 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005222 const InputInfoList &Inputs,
5223 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005224 const char *LinkingOutput) const {
5225 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005226
Daniel Dunbarc1964212009-03-26 16:23:12 +00005227 // The logic here is derived from gcc's behavior; most of which
5228 // comes from specs (starting with link_command). Consult gcc for
5229 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005230 ArgStringList CmdArgs;
5231
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005232 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5233 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5234 options::OPT_ccc_arcmt_migrate)) {
5235 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
5236 (*I)->claim();
5237 const char *Exec =
5238 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5239 CmdArgs.push_back(Output.getFilename());
5240 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5241 return;
5242 }
5243
Daniel Dunbarc1964212009-03-26 16:23:12 +00005244 // I'm not sure why this particular decomposition exists in gcc, but
5245 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005246 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005247
Daniel Dunbarc1964212009-03-26 16:23:12 +00005248 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5249 Args.AddAllArgs(CmdArgs, options::OPT_s);
5250 Args.AddAllArgs(CmdArgs, options::OPT_t);
5251 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5252 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005253 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005254 Args.AddAllArgs(CmdArgs, options::OPT_r);
5255
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005256 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5257 // members of static archive libraries which implement Objective-C classes or
5258 // categories.
5259 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5260 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005261
Daniel Dunbarc1964212009-03-26 16:23:12 +00005262 CmdArgs.push_back("-o");
5263 CmdArgs.push_back(Output.getFilename());
5264
Chad Rosier06fd3c62012-05-16 23:45:12 +00005265 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005266 !Args.hasArg(options::OPT_nostartfiles))
5267 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005268
5269 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005270
Alexey Bataev186b28a2014-03-06 05:43:53 +00005271 LibOpenMP UsedOpenMPLib = LibUnknown;
5272 if (Args.hasArg(options::OPT_fopenmp)) {
5273 UsedOpenMPLib = LibGOMP;
5274 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5275 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5276 .Case("libgomp", LibGOMP)
5277 .Case("libiomp5", LibIOMP5)
5278 .Default(LibUnknown);
5279 if (UsedOpenMPLib == LibUnknown)
5280 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5281 << A->getOption().getName() << A->getValue();
5282 }
5283 switch (UsedOpenMPLib) {
5284 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005285 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005286 break;
5287 case LibIOMP5:
5288 CmdArgs.push_back("-liomp5");
5289 break;
5290 case LibUnknown:
5291 break;
5292 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005293
Douglas Gregor9295df02012-05-15 21:00:27 +00005294 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5295
Bob Wilson16d93952012-05-15 18:57:39 +00005296 if (isObjCRuntimeLinked(Args) &&
5297 !Args.hasArg(options::OPT_nostdlib) &&
5298 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005299 // We use arclite library for both ARC and subscripting support.
5300 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5301
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005302 CmdArgs.push_back("-framework");
5303 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005304 // Link libobj.
5305 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005306 }
John McCall31168b02011-06-15 23:02:42 +00005307
Daniel Dunbarc1964212009-03-26 16:23:12 +00005308 if (LinkingOutput) {
5309 CmdArgs.push_back("-arch_multiple");
5310 CmdArgs.push_back("-final_output");
5311 CmdArgs.push_back(LinkingOutput);
5312 }
5313
Daniel Dunbarc1964212009-03-26 16:23:12 +00005314 if (Args.hasArg(options::OPT_fnested_functions))
5315 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005316
Daniel Dunbarc1964212009-03-26 16:23:12 +00005317 if (!Args.hasArg(options::OPT_nostdlib) &&
5318 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005319 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005320 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005321
Daniel Dunbarc1964212009-03-26 16:23:12 +00005322 // link_ssp spec is empty.
5323
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005324 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005325 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005326 }
5327
Chad Rosier06fd3c62012-05-16 23:45:12 +00005328 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005329 !Args.hasArg(options::OPT_nostartfiles)) {
5330 // endfile_spec is empty.
5331 }
5332
5333 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5334 Args.AddAllArgs(CmdArgs, options::OPT_F);
5335
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005336 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005337 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005338 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005339}
5340
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005341void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005342 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005343 const InputInfoList &Inputs,
5344 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005345 const char *LinkingOutput) const {
5346 ArgStringList CmdArgs;
5347
5348 CmdArgs.push_back("-create");
5349 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005350
5351 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005352 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005353
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005354 for (InputInfoList::const_iterator
5355 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5356 const InputInfo &II = *it;
5357 assert(II.isFilename() && "Unexpected lipo input.");
5358 CmdArgs.push_back(II.getFilename());
5359 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005360 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005361 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005362 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005363}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005364
Daniel Dunbar88299622010-06-04 18:28:36 +00005365void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005366 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005367 const InputInfoList &Inputs,
5368 const ArgList &Args,
5369 const char *LinkingOutput) const {
5370 ArgStringList CmdArgs;
5371
Daniel Dunbareb86b042011-05-09 17:23:16 +00005372 CmdArgs.push_back("-o");
5373 CmdArgs.push_back(Output.getFilename());
5374
Daniel Dunbar88299622010-06-04 18:28:36 +00005375 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5376 const InputInfo &Input = Inputs[0];
5377 assert(Input.isFilename() && "Unexpected dsymutil input.");
5378 CmdArgs.push_back(Input.getFilename());
5379
Daniel Dunbar88299622010-06-04 18:28:36 +00005380 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005381 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005382 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005383}
5384
Eric Christopher551ef452011-08-23 17:56:55 +00005385void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005386 const InputInfo &Output,
5387 const InputInfoList &Inputs,
5388 const ArgList &Args,
5389 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005390 ArgStringList CmdArgs;
5391 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005392 CmdArgs.push_back("--debug-info");
5393 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005394 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005395
5396 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5397 const InputInfo &Input = Inputs[0];
5398 assert(Input.isFilename() && "Unexpected verify input");
5399
5400 // Grabbing the output of the earlier dsymutil run.
5401 CmdArgs.push_back(Input.getFilename());
5402
5403 const char *Exec =
5404 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5405 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5406}
5407
David Chisnallf571cde2012-02-15 13:39:01 +00005408void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5409 const InputInfo &Output,
5410 const InputInfoList &Inputs,
5411 const ArgList &Args,
5412 const char *LinkingOutput) const {
5413 ArgStringList CmdArgs;
5414
5415 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5416 options::OPT_Xassembler);
5417
5418 CmdArgs.push_back("-o");
5419 CmdArgs.push_back(Output.getFilename());
5420
5421 for (InputInfoList::const_iterator
5422 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5423 const InputInfo &II = *it;
5424 CmdArgs.push_back(II.getFilename());
5425 }
5426
5427 const char *Exec =
5428 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5429 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5430}
5431
5432
5433void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5434 const InputInfo &Output,
5435 const InputInfoList &Inputs,
5436 const ArgList &Args,
5437 const char *LinkingOutput) const {
5438 // FIXME: Find a real GCC, don't hard-code versions here
5439 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5440 const llvm::Triple &T = getToolChain().getTriple();
5441 std::string LibPath = "/usr/lib/";
5442 llvm::Triple::ArchType Arch = T.getArch();
5443 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005444 case llvm::Triple::x86:
5445 GCCLibPath +=
5446 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5447 break;
5448 case llvm::Triple::x86_64:
5449 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5450 GCCLibPath += "/4.5.2/amd64/";
5451 LibPath += "amd64/";
5452 break;
5453 default:
5454 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005455 }
5456
5457 ArgStringList CmdArgs;
5458
David Chisnall272a0712012-02-29 15:06:12 +00005459 // Demangle C++ names in errors
5460 CmdArgs.push_back("-C");
5461
David Chisnallf571cde2012-02-15 13:39:01 +00005462 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5463 (!Args.hasArg(options::OPT_shared))) {
5464 CmdArgs.push_back("-e");
5465 CmdArgs.push_back("_start");
5466 }
5467
5468 if (Args.hasArg(options::OPT_static)) {
5469 CmdArgs.push_back("-Bstatic");
5470 CmdArgs.push_back("-dn");
5471 } else {
5472 CmdArgs.push_back("-Bdynamic");
5473 if (Args.hasArg(options::OPT_shared)) {
5474 CmdArgs.push_back("-shared");
5475 } else {
5476 CmdArgs.push_back("--dynamic-linker");
5477 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5478 }
5479 }
5480
5481 if (Output.isFilename()) {
5482 CmdArgs.push_back("-o");
5483 CmdArgs.push_back(Output.getFilename());
5484 } else {
5485 assert(Output.isNothing() && "Invalid output.");
5486 }
5487
5488 if (!Args.hasArg(options::OPT_nostdlib) &&
5489 !Args.hasArg(options::OPT_nostartfiles)) {
5490 if (!Args.hasArg(options::OPT_shared)) {
5491 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5492 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005493 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005494 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5495 } else {
5496 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005497 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5498 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005499 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005500 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005501 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005502 }
5503
5504 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5505
5506 Args.AddAllArgs(CmdArgs, options::OPT_L);
5507 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5508 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005509 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005510
5511 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5512
5513 if (!Args.hasArg(options::OPT_nostdlib) &&
5514 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005515 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005516 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005517 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005518 if (!Args.hasArg(options::OPT_shared)) {
5519 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005520 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005521 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005522 }
David Chisnallf571cde2012-02-15 13:39:01 +00005523 }
5524
5525 if (!Args.hasArg(options::OPT_nostdlib) &&
5526 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005527 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005528 }
David Chisnall96de9932012-02-16 16:00:47 +00005529 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005530
Alexey Samsonov7811d192014-02-20 13:57:37 +00005531 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005532
5533 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005534 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005535 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5536}
5537
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005538void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005539 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005540 const InputInfoList &Inputs,
5541 const ArgList &Args,
5542 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005543 ArgStringList CmdArgs;
5544
5545 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5546 options::OPT_Xassembler);
5547
5548 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005549 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005550
5551 for (InputInfoList::const_iterator
5552 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5553 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005554 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005555 }
5556
5557 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005558 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005559 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005560}
5561
5562void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005563 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005564 const InputInfoList &Inputs,
5565 const ArgList &Args,
5566 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005567 ArgStringList CmdArgs;
5568
5569 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005570 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005571 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005572 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005573 }
5574
5575 if (Args.hasArg(options::OPT_static)) {
5576 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005577 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005578 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005579// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005580 CmdArgs.push_back("-Bdynamic");
5581 if (Args.hasArg(options::OPT_shared)) {
5582 CmdArgs.push_back("-shared");
5583 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005584 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005585 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5586 }
5587 }
5588
Daniel Dunbarb440f562010-08-02 02:38:21 +00005589 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005590 CmdArgs.push_back("-o");
5591 CmdArgs.push_back(Output.getFilename());
5592 } else {
5593 assert(Output.isNothing() && "Invalid output.");
5594 }
5595
5596 if (!Args.hasArg(options::OPT_nostdlib) &&
5597 !Args.hasArg(options::OPT_nostartfiles)) {
5598 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005599 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005600 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005601 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005602 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005603 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005604 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005605 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005606 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005607 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005608 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005609 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005610 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005611 }
5612
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005613 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5614 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005615 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005616
5617 Args.AddAllArgs(CmdArgs, options::OPT_L);
5618 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5619 Args.AddAllArgs(CmdArgs, options::OPT_e);
5620
Daniel Dunbar54423b22010-09-17 00:24:54 +00005621 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005622
5623 if (!Args.hasArg(options::OPT_nostdlib) &&
5624 !Args.hasArg(options::OPT_nodefaultlibs)) {
5625 // FIXME: For some reason GCC passes -lgcc before adding
5626 // the default system libraries. Just mimic this for now.
5627 CmdArgs.push_back("-lgcc");
5628
5629 if (Args.hasArg(options::OPT_pthread))
5630 CmdArgs.push_back("-pthread");
5631 if (!Args.hasArg(options::OPT_shared))
5632 CmdArgs.push_back("-lc");
5633 CmdArgs.push_back("-lgcc");
5634 }
5635
5636 if (!Args.hasArg(options::OPT_nostdlib) &&
5637 !Args.hasArg(options::OPT_nostartfiles)) {
5638 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005639 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005640 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005641 }
5642
Alexey Samsonov7811d192014-02-20 13:57:37 +00005643 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005644
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005645 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005646 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005647 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005648}
5649
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005650void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005651 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005652 const InputInfoList &Inputs,
5653 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005654 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005655 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005656 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005657
Rafael Espindolacc126272014-02-28 01:55:21 +00005658 switch (getToolChain().getArch()) {
5659 case llvm::Triple::x86:
5660 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5661 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005662 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005663 break;
5664
5665 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005666 CmdArgs.push_back("-mppc");
5667 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005668 break;
5669
5670 case llvm::Triple::sparc:
5671 CmdArgs.push_back("-32");
5672 NeedsKPIC = true;
5673 break;
5674
5675 case llvm::Triple::sparcv9:
5676 CmdArgs.push_back("-64");
5677 CmdArgs.push_back("-Av9a");
5678 NeedsKPIC = true;
5679 break;
5680
5681 case llvm::Triple::mips64:
5682 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005683 StringRef CPUName;
5684 StringRef ABIName;
5685 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5686
5687 CmdArgs.push_back("-mabi");
5688 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5689
5690 if (getToolChain().getArch() == llvm::Triple::mips64)
5691 CmdArgs.push_back("-EB");
5692 else
5693 CmdArgs.push_back("-EL");
5694
Rafael Espindolacc126272014-02-28 01:55:21 +00005695 NeedsKPIC = true;
5696 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005697 }
5698
Rafael Espindolacc126272014-02-28 01:55:21 +00005699 default:
5700 break;
5701 }
5702
5703 if (NeedsKPIC)
5704 addAssemblerKPIC(Args, CmdArgs);
5705
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005706 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5707 options::OPT_Xassembler);
5708
5709 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005710 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005711
5712 for (InputInfoList::const_iterator
5713 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5714 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005715 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005716 }
5717
5718 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005719 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005720 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005721}
5722
5723void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005724 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005725 const InputInfoList &Inputs,
5726 const ArgList &Args,
5727 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005728 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005729 ArgStringList CmdArgs;
5730
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005731 // Silence warning for "clang -g foo.o -o foo"
5732 Args.ClaimAllArgs(options::OPT_g_Group);
5733 // and "clang -emit-llvm foo.o -o foo"
5734 Args.ClaimAllArgs(options::OPT_emit_llvm);
5735 // and for "clang -w foo.o -o foo". Other warning options are already
5736 // handled somewhere else.
5737 Args.ClaimAllArgs(options::OPT_w);
5738
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005739 if (getToolChain().getArch() == llvm::Triple::mips64)
5740 CmdArgs.push_back("-EB");
5741 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5742 CmdArgs.push_back("-EL");
5743
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005744 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005745 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005746 CmdArgs.push_back("-e");
5747 CmdArgs.push_back("__start");
5748 }
5749
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005750 if (Args.hasArg(options::OPT_static)) {
5751 CmdArgs.push_back("-Bstatic");
5752 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005753 if (Args.hasArg(options::OPT_rdynamic))
5754 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005755 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005756 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005757 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005758 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005759 } else {
5760 CmdArgs.push_back("-dynamic-linker");
5761 CmdArgs.push_back("/usr/libexec/ld.so");
5762 }
5763 }
5764
Rafael Espindola044f7832013-06-05 04:28:55 +00005765 if (Args.hasArg(options::OPT_nopie))
5766 CmdArgs.push_back("-nopie");
5767
Daniel Dunbarb440f562010-08-02 02:38:21 +00005768 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005769 CmdArgs.push_back("-o");
5770 CmdArgs.push_back(Output.getFilename());
5771 } else {
5772 assert(Output.isNothing() && "Invalid output.");
5773 }
5774
5775 if (!Args.hasArg(options::OPT_nostdlib) &&
5776 !Args.hasArg(options::OPT_nostartfiles)) {
5777 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00005778 if (Args.hasArg(options::OPT_pg))
5779 CmdArgs.push_back(Args.MakeArgString(
5780 getToolChain().GetFilePath("gcrt0.o")));
5781 else
5782 CmdArgs.push_back(Args.MakeArgString(
5783 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005784 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005785 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005786 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005787 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005788 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005789 }
5790 }
5791
Edward O'Callaghan5c521462009-10-28 15:13:08 +00005792 std::string Triple = getToolChain().getTripleString();
5793 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005794 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005795 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005796 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005797
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005798 Args.AddAllArgs(CmdArgs, options::OPT_L);
5799 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5800 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005801 Args.AddAllArgs(CmdArgs, options::OPT_s);
5802 Args.AddAllArgs(CmdArgs, options::OPT_t);
5803 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5804 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005805
Daniel Dunbar54423b22010-09-17 00:24:54 +00005806 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005807
5808 if (!Args.hasArg(options::OPT_nostdlib) &&
5809 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005810 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005811 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00005812 if (Args.hasArg(options::OPT_pg))
5813 CmdArgs.push_back("-lm_p");
5814 else
5815 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005816 }
5817
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005818 // FIXME: For some reason GCC passes -lgcc before adding
5819 // the default system libraries. Just mimic this for now.
5820 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005821
Eric Christopher17674ec2012-09-13 06:32:34 +00005822 if (Args.hasArg(options::OPT_pthread)) {
5823 if (!Args.hasArg(options::OPT_shared) &&
5824 Args.hasArg(options::OPT_pg))
5825 CmdArgs.push_back("-lpthread_p");
5826 else
5827 CmdArgs.push_back("-lpthread");
5828 }
5829
Chandler Carruth45661652011-12-17 22:32:42 +00005830 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00005831 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00005832 CmdArgs.push_back("-lc_p");
5833 else
5834 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00005835 }
Eric Christopher17674ec2012-09-13 06:32:34 +00005836
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005837 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005838 }
5839
5840 if (!Args.hasArg(options::OPT_nostdlib) &&
5841 !Args.hasArg(options::OPT_nostartfiles)) {
5842 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005843 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005844 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005845 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005846 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005847 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005848 }
5849
5850 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005851 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005852 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005853}
Ed Schoutene33194b2009-04-02 19:13:12 +00005854
Eli Friedman9fa28852012-08-08 23:57:20 +00005855void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5856 const InputInfo &Output,
5857 const InputInfoList &Inputs,
5858 const ArgList &Args,
5859 const char *LinkingOutput) const {
5860 ArgStringList CmdArgs;
5861
5862 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5863 options::OPT_Xassembler);
5864
5865 CmdArgs.push_back("-o");
5866 CmdArgs.push_back(Output.getFilename());
5867
5868 for (InputInfoList::const_iterator
5869 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5870 const InputInfo &II = *it;
5871 CmdArgs.push_back(II.getFilename());
5872 }
5873
5874 const char *Exec =
5875 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5876 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5877}
5878
5879void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5880 const InputInfo &Output,
5881 const InputInfoList &Inputs,
5882 const ArgList &Args,
5883 const char *LinkingOutput) const {
5884 const Driver &D = getToolChain().getDriver();
5885 ArgStringList CmdArgs;
5886
5887 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5888 (!Args.hasArg(options::OPT_shared))) {
5889 CmdArgs.push_back("-e");
5890 CmdArgs.push_back("__start");
5891 }
5892
5893 if (Args.hasArg(options::OPT_static)) {
5894 CmdArgs.push_back("-Bstatic");
5895 } else {
5896 if (Args.hasArg(options::OPT_rdynamic))
5897 CmdArgs.push_back("-export-dynamic");
5898 CmdArgs.push_back("--eh-frame-hdr");
5899 CmdArgs.push_back("-Bdynamic");
5900 if (Args.hasArg(options::OPT_shared)) {
5901 CmdArgs.push_back("-shared");
5902 } else {
5903 CmdArgs.push_back("-dynamic-linker");
5904 CmdArgs.push_back("/usr/libexec/ld.so");
5905 }
5906 }
5907
5908 if (Output.isFilename()) {
5909 CmdArgs.push_back("-o");
5910 CmdArgs.push_back(Output.getFilename());
5911 } else {
5912 assert(Output.isNothing() && "Invalid output.");
5913 }
5914
5915 if (!Args.hasArg(options::OPT_nostdlib) &&
5916 !Args.hasArg(options::OPT_nostartfiles)) {
5917 if (!Args.hasArg(options::OPT_shared)) {
5918 if (Args.hasArg(options::OPT_pg))
5919 CmdArgs.push_back(Args.MakeArgString(
5920 getToolChain().GetFilePath("gcrt0.o")));
5921 else
5922 CmdArgs.push_back(Args.MakeArgString(
5923 getToolChain().GetFilePath("crt0.o")));
5924 CmdArgs.push_back(Args.MakeArgString(
5925 getToolChain().GetFilePath("crtbegin.o")));
5926 } else {
5927 CmdArgs.push_back(Args.MakeArgString(
5928 getToolChain().GetFilePath("crtbeginS.o")));
5929 }
5930 }
5931
5932 Args.AddAllArgs(CmdArgs, options::OPT_L);
5933 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5934 Args.AddAllArgs(CmdArgs, options::OPT_e);
5935
5936 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5937
5938 if (!Args.hasArg(options::OPT_nostdlib) &&
5939 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005940 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00005941 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5942 if (Args.hasArg(options::OPT_pg))
5943 CmdArgs.push_back("-lm_p");
5944 else
5945 CmdArgs.push_back("-lm");
5946 }
5947
Rafael Espindola1ad26f02012-10-23 17:07:31 +00005948 if (Args.hasArg(options::OPT_pthread)) {
5949 if (!Args.hasArg(options::OPT_shared) &&
5950 Args.hasArg(options::OPT_pg))
5951 CmdArgs.push_back("-lpthread_p");
5952 else
5953 CmdArgs.push_back("-lpthread");
5954 }
5955
Eli Friedman9fa28852012-08-08 23:57:20 +00005956 if (!Args.hasArg(options::OPT_shared)) {
5957 if (Args.hasArg(options::OPT_pg))
5958 CmdArgs.push_back("-lc_p");
5959 else
5960 CmdArgs.push_back("-lc");
5961 }
5962
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005963 StringRef MyArch;
5964 switch (getToolChain().getTriple().getArch()) {
5965 case llvm::Triple::arm:
5966 MyArch = "arm";
5967 break;
5968 case llvm::Triple::x86:
5969 MyArch = "i386";
5970 break;
5971 case llvm::Triple::x86_64:
5972 MyArch = "amd64";
5973 break;
5974 default:
5975 llvm_unreachable("Unsupported architecture");
5976 }
5977 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00005978 }
5979
5980 if (!Args.hasArg(options::OPT_nostdlib) &&
5981 !Args.hasArg(options::OPT_nostartfiles)) {
5982 if (!Args.hasArg(options::OPT_shared))
5983 CmdArgs.push_back(Args.MakeArgString(
5984 getToolChain().GetFilePath("crtend.o")));
5985 else
5986 CmdArgs.push_back(Args.MakeArgString(
5987 getToolChain().GetFilePath("crtendS.o")));
5988 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005989
5990 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005991 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005992 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00005993}
5994
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005995void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005996 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005997 const InputInfoList &Inputs,
5998 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005999 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006000 ArgStringList CmdArgs;
6001
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006002 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6003 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006004 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006005 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006006 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006007 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006008 else if (getToolChain().getArch() == llvm::Triple::mips ||
6009 getToolChain().getArch() == llvm::Triple::mipsel ||
6010 getToolChain().getArch() == llvm::Triple::mips64 ||
6011 getToolChain().getArch() == llvm::Triple::mips64el) {
6012 StringRef CPUName;
6013 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006014 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006015
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006016 CmdArgs.push_back("-march");
6017 CmdArgs.push_back(CPUName.data());
6018
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006019 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006020 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006021
6022 if (getToolChain().getArch() == llvm::Triple::mips ||
6023 getToolChain().getArch() == llvm::Triple::mips64)
6024 CmdArgs.push_back("-EB");
6025 else
6026 CmdArgs.push_back("-EL");
6027
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006028 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006029 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6030 getToolChain().getArch() == llvm::Triple::thumb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006031 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006032 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006033 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6034
6035 if (FloatABI == "hard") {
6036 CmdArgs.push_back("-mfpu=vfp");
6037 } else {
6038 CmdArgs.push_back("-mfpu=softvfp");
6039 }
6040
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006041 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006042 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006043 case llvm::Triple::GNUEABI:
6044 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006045 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006046 break;
6047
6048 default:
6049 CmdArgs.push_back("-matpcs");
6050 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006051 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006052 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006053 if (getToolChain().getArch() == llvm::Triple::sparc)
6054 CmdArgs.push_back("-Av8plusa");
6055 else
6056 CmdArgs.push_back("-Av9a");
6057
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006058 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006059 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006060
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006061 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6062 options::OPT_Xassembler);
6063
6064 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006065 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006066
6067 for (InputInfoList::const_iterator
6068 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6069 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006070 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006071 }
6072
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006073 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006074 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006075 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006076}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006077
6078void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006079 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006080 const InputInfoList &Inputs,
6081 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006082 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006083 const toolchains::FreeBSD& ToolChain =
6084 static_cast<const toolchains::FreeBSD&>(getToolChain());
6085 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006086 const bool IsPIE =
6087 !Args.hasArg(options::OPT_shared) &&
6088 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006089 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006090
6091 // Silence warning for "clang -g foo.o -o foo"
6092 Args.ClaimAllArgs(options::OPT_g_Group);
6093 // and "clang -emit-llvm foo.o -o foo"
6094 Args.ClaimAllArgs(options::OPT_emit_llvm);
6095 // and for "clang -w foo.o -o foo". Other warning options are already
6096 // handled somewhere else.
6097 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006098
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006099 if (!D.SysRoot.empty())
6100 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6101
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006102 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006103 CmdArgs.push_back("-pie");
6104
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006105 if (Args.hasArg(options::OPT_static)) {
6106 CmdArgs.push_back("-Bstatic");
6107 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006108 if (Args.hasArg(options::OPT_rdynamic))
6109 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006110 CmdArgs.push_back("--eh-frame-hdr");
6111 if (Args.hasArg(options::OPT_shared)) {
6112 CmdArgs.push_back("-Bshareable");
6113 } else {
6114 CmdArgs.push_back("-dynamic-linker");
6115 CmdArgs.push_back("/libexec/ld-elf.so.1");
6116 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006117 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6118 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006119 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6120 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6121 CmdArgs.push_back("--hash-style=both");
6122 }
6123 }
6124 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006125 }
6126
6127 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6128 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006129 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006130 CmdArgs.push_back("-m");
6131 CmdArgs.push_back("elf_i386_fbsd");
6132 }
6133
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006134 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006135 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006136 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006137 }
6138
Daniel Dunbarb440f562010-08-02 02:38:21 +00006139 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006140 CmdArgs.push_back("-o");
6141 CmdArgs.push_back(Output.getFilename());
6142 } else {
6143 assert(Output.isNothing() && "Invalid output.");
6144 }
6145
6146 if (!Args.hasArg(options::OPT_nostdlib) &&
6147 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006148 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006149 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006150 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006151 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006152 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006153 crt1 = "Scrt1.o";
6154 else
6155 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006156 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006157 if (crt1)
6158 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6159
6160 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6161
6162 const char *crtbegin = NULL;
6163 if (Args.hasArg(options::OPT_static))
6164 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006165 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006166 crtbegin = "crtbeginS.o";
6167 else
6168 crtbegin = "crtbegin.o";
6169
6170 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006171 }
6172
6173 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006174 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00006175 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6176 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006177 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006178 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6179 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006180 Args.AddAllArgs(CmdArgs, options::OPT_s);
6181 Args.AddAllArgs(CmdArgs, options::OPT_t);
6182 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6183 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006184
Alp Tokerce365ca2013-12-02 12:43:03 +00006185 if (D.IsUsingLTO(Args))
6186 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006187
Roman Divackyafe2f232012-08-28 15:09:03 +00006188 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006189
6190 if (!Args.hasArg(options::OPT_nostdlib) &&
6191 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006192 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006193 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006194 if (Args.hasArg(options::OPT_pg))
6195 CmdArgs.push_back("-lm_p");
6196 else
6197 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006198 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006199 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6200 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006201 if (Args.hasArg(options::OPT_pg))
6202 CmdArgs.push_back("-lgcc_p");
6203 else
6204 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006205 if (Args.hasArg(options::OPT_static)) {
6206 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006207 } else if (Args.hasArg(options::OPT_pg)) {
6208 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006209 } else {
6210 CmdArgs.push_back("--as-needed");
6211 CmdArgs.push_back("-lgcc_s");
6212 CmdArgs.push_back("--no-as-needed");
6213 }
6214
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006215 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006216 if (Args.hasArg(options::OPT_pg))
6217 CmdArgs.push_back("-lpthread_p");
6218 else
6219 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006220 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006221
Roman Divacky66f22762011-02-10 16:59:40 +00006222 if (Args.hasArg(options::OPT_pg)) {
6223 if (Args.hasArg(options::OPT_shared))
6224 CmdArgs.push_back("-lc");
6225 else
6226 CmdArgs.push_back("-lc_p");
6227 CmdArgs.push_back("-lgcc_p");
6228 } else {
6229 CmdArgs.push_back("-lc");
6230 CmdArgs.push_back("-lgcc");
6231 }
6232
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006233 if (Args.hasArg(options::OPT_static)) {
6234 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006235 } else if (Args.hasArg(options::OPT_pg)) {
6236 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006237 } else {
6238 CmdArgs.push_back("--as-needed");
6239 CmdArgs.push_back("-lgcc_s");
6240 CmdArgs.push_back("--no-as-needed");
6241 }
6242 }
6243
6244 if (!Args.hasArg(options::OPT_nostdlib) &&
6245 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006246 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006247 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006248 else
6249 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006250 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006251 }
6252
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006253 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6254
Alexey Samsonov7811d192014-02-20 13:57:37 +00006255 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006256
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006257 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006258 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006259 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006260}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006261
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006262void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6263 const InputInfo &Output,
6264 const InputInfoList &Inputs,
6265 const ArgList &Args,
6266 const char *LinkingOutput) const {
6267 ArgStringList CmdArgs;
6268
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006269 // GNU as needs different flags for creating the correct output format
6270 // on architectures with different ABIs or optional feature sets.
6271 switch (getToolChain().getArch()) {
6272 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006273 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006274 break;
6275 case llvm::Triple::arm:
6276 case llvm::Triple::thumb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006277 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006278 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006279 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006280 }
6281
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006282 case llvm::Triple::mips:
6283 case llvm::Triple::mipsel:
6284 case llvm::Triple::mips64:
6285 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006286 StringRef CPUName;
6287 StringRef ABIName;
6288 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6289
6290 CmdArgs.push_back("-march");
6291 CmdArgs.push_back(CPUName.data());
6292
6293 CmdArgs.push_back("-mabi");
6294 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6295
6296 if (getToolChain().getArch() == llvm::Triple::mips ||
6297 getToolChain().getArch() == llvm::Triple::mips64)
6298 CmdArgs.push_back("-EB");
6299 else
6300 CmdArgs.push_back("-EL");
6301
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006302 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006303 break;
6304 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006305
6306 case llvm::Triple::sparc:
6307 CmdArgs.push_back("-32");
6308 addAssemblerKPIC(Args, CmdArgs);
6309 break;
6310
6311 case llvm::Triple::sparcv9:
6312 CmdArgs.push_back("-64");
6313 CmdArgs.push_back("-Av9");
6314 addAssemblerKPIC(Args, CmdArgs);
6315 break;
6316
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006317 default:
6318 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006319 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006320
6321 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6322 options::OPT_Xassembler);
6323
6324 CmdArgs.push_back("-o");
6325 CmdArgs.push_back(Output.getFilename());
6326
6327 for (InputInfoList::const_iterator
6328 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6329 const InputInfo &II = *it;
6330 CmdArgs.push_back(II.getFilename());
6331 }
6332
David Chisnallddbd68f2011-09-27 22:03:18 +00006333 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006334 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6335}
6336
6337void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6338 const InputInfo &Output,
6339 const InputInfoList &Inputs,
6340 const ArgList &Args,
6341 const char *LinkingOutput) const {
6342 const Driver &D = getToolChain().getDriver();
6343 ArgStringList CmdArgs;
6344
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006345 if (!D.SysRoot.empty())
6346 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6347
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006348 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006349 if (Args.hasArg(options::OPT_static)) {
6350 CmdArgs.push_back("-Bstatic");
6351 } else {
6352 if (Args.hasArg(options::OPT_rdynamic))
6353 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006354 if (Args.hasArg(options::OPT_shared)) {
6355 CmdArgs.push_back("-Bshareable");
6356 } else {
6357 CmdArgs.push_back("-dynamic-linker");
6358 CmdArgs.push_back("/libexec/ld.elf_so");
6359 }
6360 }
6361
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006362 // Many NetBSD architectures support more than one ABI.
6363 // Determine the correct emulation for ld.
6364 switch (getToolChain().getArch()) {
6365 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006366 CmdArgs.push_back("-m");
6367 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006368 break;
6369 case llvm::Triple::arm:
6370 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006371 CmdArgs.push_back("-m");
6372 switch (getToolChain().getTriple().getEnvironment()) {
6373 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006374 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006375 CmdArgs.push_back("armelf_nbsd_eabi");
6376 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006377 case llvm::Triple::EABIHF:
6378 case llvm::Triple::GNUEABIHF:
6379 CmdArgs.push_back("armelf_nbsd_eabihf");
6380 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006381 default:
6382 CmdArgs.push_back("armelf_nbsd");
6383 break;
6384 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006385 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006386 case llvm::Triple::mips64:
6387 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006388 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006389 CmdArgs.push_back("-m");
6390 if (getToolChain().getArch() == llvm::Triple::mips64)
6391 CmdArgs.push_back("elf32btsmip");
6392 else
6393 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006394 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006395 CmdArgs.push_back("-m");
6396 if (getToolChain().getArch() == llvm::Triple::mips64)
6397 CmdArgs.push_back("elf64btsmip");
6398 else
6399 CmdArgs.push_back("elf64ltsmip");
6400 }
6401 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006402
6403 case llvm::Triple::sparc:
6404 CmdArgs.push_back("-m");
6405 CmdArgs.push_back("elf32_sparc");
6406 break;
6407
6408 case llvm::Triple::sparcv9:
6409 CmdArgs.push_back("-m");
6410 CmdArgs.push_back("elf64_sparc");
6411 break;
6412
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006413 default:
6414 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006415 }
6416
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006417 if (Output.isFilename()) {
6418 CmdArgs.push_back("-o");
6419 CmdArgs.push_back(Output.getFilename());
6420 } else {
6421 assert(Output.isNothing() && "Invalid output.");
6422 }
6423
6424 if (!Args.hasArg(options::OPT_nostdlib) &&
6425 !Args.hasArg(options::OPT_nostartfiles)) {
6426 if (!Args.hasArg(options::OPT_shared)) {
6427 CmdArgs.push_back(Args.MakeArgString(
6428 getToolChain().GetFilePath("crt0.o")));
6429 CmdArgs.push_back(Args.MakeArgString(
6430 getToolChain().GetFilePath("crti.o")));
6431 CmdArgs.push_back(Args.MakeArgString(
6432 getToolChain().GetFilePath("crtbegin.o")));
6433 } else {
6434 CmdArgs.push_back(Args.MakeArgString(
6435 getToolChain().GetFilePath("crti.o")));
6436 CmdArgs.push_back(Args.MakeArgString(
6437 getToolChain().GetFilePath("crtbeginS.o")));
6438 }
6439 }
6440
6441 Args.AddAllArgs(CmdArgs, options::OPT_L);
6442 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6443 Args.AddAllArgs(CmdArgs, options::OPT_e);
6444 Args.AddAllArgs(CmdArgs, options::OPT_s);
6445 Args.AddAllArgs(CmdArgs, options::OPT_t);
6446 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6447 Args.AddAllArgs(CmdArgs, options::OPT_r);
6448
6449 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6450
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006451 unsigned Major, Minor, Micro;
6452 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6453 bool useLibgcc = true;
6454 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006455 switch(getToolChain().getArch()) {
6456 case llvm::Triple::x86:
6457 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006458 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006459 break;
6460 default:
6461 break;
6462 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006463 }
6464
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006465 if (!Args.hasArg(options::OPT_nostdlib) &&
6466 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006467 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006468 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6469 CmdArgs.push_back("-lm");
6470 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006471 if (Args.hasArg(options::OPT_pthread))
6472 CmdArgs.push_back("-lpthread");
6473 CmdArgs.push_back("-lc");
6474
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006475 if (useLibgcc) {
6476 if (Args.hasArg(options::OPT_static)) {
6477 // libgcc_eh depends on libc, so resolve as much as possible,
6478 // pull in any new requirements from libc and then get the rest
6479 // of libgcc.
6480 CmdArgs.push_back("-lgcc_eh");
6481 CmdArgs.push_back("-lc");
6482 CmdArgs.push_back("-lgcc");
6483 } else {
6484 CmdArgs.push_back("-lgcc");
6485 CmdArgs.push_back("--as-needed");
6486 CmdArgs.push_back("-lgcc_s");
6487 CmdArgs.push_back("--no-as-needed");
6488 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006489 }
6490 }
6491
6492 if (!Args.hasArg(options::OPT_nostdlib) &&
6493 !Args.hasArg(options::OPT_nostartfiles)) {
6494 if (!Args.hasArg(options::OPT_shared))
6495 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6496 "crtend.o")));
6497 else
6498 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6499 "crtendS.o")));
6500 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6501 "crtn.o")));
6502 }
6503
Alexey Samsonov7811d192014-02-20 13:57:37 +00006504 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006505
Rafael Espindola236db462013-11-09 20:07:19 +00006506 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006507 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6508}
6509
Thomas Schwinge4e555262013-03-28 19:04:25 +00006510void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6511 const InputInfo &Output,
6512 const InputInfoList &Inputs,
6513 const ArgList &Args,
6514 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006515 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006516 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006517
6518 // Add --32/--64 to make sure we get the format we want.
6519 // This is incomplete
6520 if (getToolChain().getArch() == llvm::Triple::x86) {
6521 CmdArgs.push_back("--32");
6522 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6523 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006524 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6525 CmdArgs.push_back("-a32");
6526 CmdArgs.push_back("-mppc");
6527 CmdArgs.push_back("-many");
6528 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6529 CmdArgs.push_back("-a64");
6530 CmdArgs.push_back("-mppc64");
6531 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006532 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6533 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006534 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006535 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006536 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006537 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6538 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006539 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006540 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006541 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6542 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006543 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006544 NeedsKPIC = true;
Rafael Espindola92b00932010-08-10 00:25:48 +00006545 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006546 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006547 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6548 CmdArgs.push_back("-mfpu=neon");
Bernard Ogdena58ef052013-10-24 18:32:41 +00006549 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6550 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006551
Tim Northover9c7e0352013-12-12 11:55:52 +00006552 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6553 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006554 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006555
6556 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006557
6558 // FIXME: remove krait check when GNU tools support krait cpu
6559 // for now replace it with -march=armv7-a to avoid a lower
6560 // march from being picked in the absence of a cpu flag.
6561 Arg *A;
6562 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6563 StringRef(A->getValue()) == "krait")
6564 CmdArgs.push_back("-march=armv7-a");
6565 else
6566 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006567 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006568 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6569 getToolChain().getArch() == llvm::Triple::mipsel ||
6570 getToolChain().getArch() == llvm::Triple::mips64 ||
6571 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006572 StringRef CPUName;
6573 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006574 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006575
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006576 CmdArgs.push_back("-march");
6577 CmdArgs.push_back(CPUName.data());
6578
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006579 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006580 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006581
6582 if (getToolChain().getArch() == llvm::Triple::mips ||
6583 getToolChain().getArch() == llvm::Triple::mips64)
6584 CmdArgs.push_back("-EB");
6585 else
6586 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006587
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006588 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6589 if (StringRef(A->getValue()) == "2008")
6590 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6591 }
6592
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006593 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006594 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6595 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6596 options::OPT_mno_micromips);
6597 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6598 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6599
Simon Atanasyanbd986632013-11-26 11:58:04 +00006600 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6601 // Do not use AddLastArg because not all versions of MIPS assembler
6602 // support -mmsa / -mno-msa options.
6603 if (A->getOption().matches(options::OPT_mmsa))
6604 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6605 }
6606
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006607 NeedsKPIC = true;
6608 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6609 // Always pass an -march option, since our default of z10 is later
6610 // than the GNU assembler's default.
6611 StringRef CPUName = getSystemZTargetCPU(Args);
6612 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6613 }
6614
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006615 if (NeedsKPIC)
6616 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006617
6618 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6619 options::OPT_Xassembler);
6620
6621 CmdArgs.push_back("-o");
6622 CmdArgs.push_back(Output.getFilename());
6623
6624 for (InputInfoList::const_iterator
6625 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6626 const InputInfo &II = *it;
6627 CmdArgs.push_back(II.getFilename());
6628 }
6629
6630 const char *Exec =
6631 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6632 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006633
6634 // Handle the debug info splitting at object creation time if we're
6635 // creating an object.
6636 // TODO: Currently only works on linux with newer objcopy.
6637 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006638 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006639 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6640 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006641}
6642
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006643static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006644 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006645 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006646 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6647 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006648 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006649 CmdArgs.push_back("-lgcc");
6650
Logan Chien3d3373c2012-11-19 12:04:11 +00006651 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006652 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006653 CmdArgs.push_back("-lgcc");
6654 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006655 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006656 CmdArgs.push_back("--as-needed");
6657 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006658 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006659 CmdArgs.push_back("--no-as-needed");
6660 }
6661
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006662 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006663 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006664 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006665 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006666
6667 // According to Android ABI, we have to link with libdl if we are
6668 // linking with non-static libgcc.
6669 //
6670 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6671 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6672 if (isAndroid && !StaticLibgcc)
6673 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006674}
6675
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006676static StringRef getLinuxDynamicLinker(const ArgList &Args,
6677 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006678 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6679 if (ToolChain.getTriple().isArch64Bit())
6680 return "/system/bin/linker64";
6681 else
6682 return "/system/bin/linker";
6683 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6684 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006685 return "/lib/ld-linux.so.2";
6686 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6687 return "/lib/ld-linux-aarch64.so.1";
Christian Pirkera74c7912014-03-14 12:15:45 +00006688 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6689 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006690 else if (ToolChain.getArch() == llvm::Triple::arm ||
6691 ToolChain.getArch() == llvm::Triple::thumb) {
6692 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6693 return "/lib/ld-linux-armhf.so.3";
6694 else
6695 return "/lib/ld-linux.so.3";
6696 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6697 ToolChain.getArch() == llvm::Triple::mipsel)
6698 return "/lib/ld.so.1";
6699 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6700 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006701 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006702 return "/lib32/ld.so.1";
6703 else
6704 return "/lib64/ld.so.1";
6705 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6706 return "/lib/ld.so.1";
6707 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidt778d3872013-07-26 01:36:11 +00006708 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006709 ToolChain.getArch() == llvm::Triple::systemz)
6710 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006711 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6712 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006713 else
6714 return "/lib64/ld-linux-x86-64.so.2";
6715}
6716
Renato Golinc4b49242014-02-13 10:01:16 +00006717static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6718 ArgStringList &CmdArgs, const ArgList &Args) {
6719 // Make use of compiler-rt if --rtlib option is used
6720 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6721
6722 switch(RLT) {
6723 case ToolChain::RLT_CompilerRT:
6724 addClangRTLinux(TC, Args, CmdArgs);
6725 break;
6726 case ToolChain::RLT_Libgcc:
6727 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6728 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006729 }
6730}
6731
Thomas Schwinge4e555262013-03-28 19:04:25 +00006732void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6733 const InputInfo &Output,
6734 const InputInfoList &Inputs,
6735 const ArgList &Args,
6736 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006737 const toolchains::Linux& ToolChain =
6738 static_cast<const toolchains::Linux&>(getToolChain());
6739 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006740 const bool isAndroid =
6741 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006742 const bool IsPIE =
6743 !Args.hasArg(options::OPT_shared) &&
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006744 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006745
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006746 ArgStringList CmdArgs;
6747
Rafael Espindolad1002f62010-11-15 18:28:16 +00006748 // Silence warning for "clang -g foo.o -o foo"
6749 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006750 // and "clang -emit-llvm foo.o -o foo"
6751 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00006752 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00006753 // handled somewhere else.
6754 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00006755
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006756 if (!D.SysRoot.empty())
6757 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006758
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006759 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00006760 CmdArgs.push_back("-pie");
6761
Rafael Espindola1c76c592010-11-07 22:57:16 +00006762 if (Args.hasArg(options::OPT_rdynamic))
6763 CmdArgs.push_back("-export-dynamic");
6764
Rafael Espindola34d77dc2010-11-11 19:34:42 +00006765 if (Args.hasArg(options::OPT_s))
6766 CmdArgs.push_back("-s");
6767
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006768 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6769 e = ToolChain.ExtraOpts.end();
6770 i != e; ++i)
6771 CmdArgs.push_back(i->c_str());
6772
6773 if (!Args.hasArg(options::OPT_static)) {
6774 CmdArgs.push_back("--eh-frame-hdr");
6775 }
6776
6777 CmdArgs.push_back("-m");
6778 if (ToolChain.getArch() == llvm::Triple::x86)
6779 CmdArgs.push_back("elf_i386");
Tim Northover9bb857a2013-01-31 12:13:10 +00006780 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6781 CmdArgs.push_back("aarch64linux");
Christian Pirkera74c7912014-03-14 12:15:45 +00006782 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6783 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00006784 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00006785 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006786 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00006787 else if (ToolChain.getArch() == llvm::Triple::ppc)
6788 CmdArgs.push_back("elf32ppclinux");
6789 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6790 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006791 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
6792 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00006793 else if (ToolChain.getArch() == llvm::Triple::sparc)
6794 CmdArgs.push_back("elf32_sparc");
6795 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6796 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00006797 else if (ToolChain.getArch() == llvm::Triple::mips)
6798 CmdArgs.push_back("elf32btsmip");
6799 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6800 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006801 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006802 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006803 CmdArgs.push_back("elf32btsmipn32");
6804 else
6805 CmdArgs.push_back("elf64btsmip");
6806 }
6807 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006808 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006809 CmdArgs.push_back("elf32ltsmipn32");
6810 else
6811 CmdArgs.push_back("elf64ltsmip");
6812 }
Ulrich Weigand47445072013-05-06 16:26:41 +00006813 else if (ToolChain.getArch() == llvm::Triple::systemz)
6814 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006815 else
6816 CmdArgs.push_back("elf_x86_64");
6817
6818 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00006819 if (ToolChain.getArch() == llvm::Triple::arm ||
6820 ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006821 CmdArgs.push_back("-Bstatic");
6822 else
6823 CmdArgs.push_back("-static");
6824 } else if (Args.hasArg(options::OPT_shared)) {
6825 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00006826 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006827 CmdArgs.push_back("-Bsymbolic");
6828 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006829 }
6830
6831 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00006832 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006833 (!Args.hasArg(options::OPT_static) &&
6834 !Args.hasArg(options::OPT_shared))) {
6835 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006836 CmdArgs.push_back(Args.MakeArgString(
6837 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006838 }
6839
6840 CmdArgs.push_back("-o");
6841 CmdArgs.push_back(Output.getFilename());
6842
Rafael Espindola81937ec2010-12-01 01:52:43 +00006843 if (!Args.hasArg(options::OPT_nostdlib) &&
6844 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006845 if (!isAndroid) {
6846 const char *crt1 = NULL;
6847 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00006848 if (Args.hasArg(options::OPT_pg))
6849 crt1 = "gcrt1.o";
6850 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006851 crt1 = "Scrt1.o";
6852 else
6853 crt1 = "crt1.o";
6854 }
6855 if (crt1)
6856 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006857
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006858 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6859 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006860
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006861 const char *crtbegin;
6862 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006863 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006864 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006865 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006866 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006867 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006868 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006869 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006870 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00006871
6872 // Add crtfastmath.o if available and fast math is enabled.
6873 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006874 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006875
6876 Args.AddAllArgs(CmdArgs, options::OPT_L);
6877
6878 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6879
Roman Divackyee8188a2011-03-01 17:53:14 +00006880 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6881 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006882 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006883
Alp Tokerce365ca2013-12-02 12:43:03 +00006884 if (D.IsUsingLTO(Args))
6885 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00006886
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00006887 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6888 CmdArgs.push_back("--no-demangle");
6889
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006890 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6891
Alexey Samsonovce8ab102014-02-25 12:43:43 +00006892 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006893 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00006894 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006895
Hans Wennborg70850d82013-07-18 20:29:38 +00006896 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00006897 !Args.hasArg(options::OPT_nostdlib) &&
6898 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00006899 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6900 !Args.hasArg(options::OPT_static);
6901 if (OnlyLibstdcxxStatic)
6902 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006903 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00006904 if (OnlyLibstdcxxStatic)
6905 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006906 CmdArgs.push_back("-lm");
6907 }
6908
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006909 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00006910 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6911 if (Args.hasArg(options::OPT_static))
6912 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00006913
Alexey Bataev186b28a2014-03-06 05:43:53 +00006914 LibOpenMP UsedOpenMPLib = LibUnknown;
6915 if (Args.hasArg(options::OPT_fopenmp)) {
6916 UsedOpenMPLib = LibGOMP;
6917 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
6918 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
6919 .Case("libgomp", LibGOMP)
6920 .Case("libiomp5", LibIOMP5)
6921 .Default(LibUnknown);
6922 if (UsedOpenMPLib == LibUnknown)
6923 D.Diag(diag::err_drv_unsupported_option_argument)
6924 << A->getOption().getName() << A->getValue();
6925 }
6926 switch (UsedOpenMPLib) {
6927 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00006928 CmdArgs.push_back("-lgomp");
6929
Alp Tokerf6a24ce2013-12-05 16:25:25 +00006930 // FIXME: Exclude this for platforms with libgomp that don't require
6931 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00006932 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00006933 break;
6934 case LibIOMP5:
6935 CmdArgs.push_back("-liomp5");
6936 break;
6937 case LibUnknown:
6938 break;
Chandler Carruth01538002013-01-17 13:19:29 +00006939 }
Renato Golinc4b49242014-02-13 10:01:16 +00006940 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006941
Chandler Carruth94a32012012-05-14 18:31:18 +00006942 if (Args.hasArg(options::OPT_pthread) ||
Alexey Bataev648250a2014-03-07 07:43:52 +00006943 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown)
Chandler Carruth94a32012012-05-14 18:31:18 +00006944 CmdArgs.push_back("-lpthread");
6945
6946 CmdArgs.push_back("-lc");
6947
6948 if (Args.hasArg(options::OPT_static))
6949 CmdArgs.push_back("--end-group");
6950 else
Renato Golinc4b49242014-02-13 10:01:16 +00006951 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00006952 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00006953
Rafael Espindola81937ec2010-12-01 01:52:43 +00006954 if (!Args.hasArg(options::OPT_nostartfiles)) {
6955 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006956 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006957 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006958 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006959 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00006960 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006961 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006962
Rafael Espindola81937ec2010-12-01 01:52:43 +00006963 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006964 if (!isAndroid)
6965 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00006966 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006967 }
6968
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006969 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6970}
Rafael Espindola92b00932010-08-10 00:25:48 +00006971
Chris Lattner3e2ee142010-07-07 16:01:42 +00006972void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006973 const InputInfo &Output,
6974 const InputInfoList &Inputs,
6975 const ArgList &Args,
6976 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006977 ArgStringList CmdArgs;
6978
6979 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6980 options::OPT_Xassembler);
6981
6982 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006983 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006984
6985 for (InputInfoList::const_iterator
6986 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6987 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006988 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006989 }
6990
6991 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00006992 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006993 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006994}
6995
6996void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006997 const InputInfo &Output,
6998 const InputInfoList &Inputs,
6999 const ArgList &Args,
7000 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007001 const Driver &D = getToolChain().getDriver();
7002 ArgStringList CmdArgs;
7003
Daniel Dunbarb440f562010-08-02 02:38:21 +00007004 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007005 CmdArgs.push_back("-o");
7006 CmdArgs.push_back(Output.getFilename());
7007 } else {
7008 assert(Output.isNothing() && "Invalid output.");
7009 }
7010
7011 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007012 !Args.hasArg(options::OPT_nostartfiles)) {
7013 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7014 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7015 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7016 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7017 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007018
7019 Args.AddAllArgs(CmdArgs, options::OPT_L);
7020 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7021 Args.AddAllArgs(CmdArgs, options::OPT_e);
7022
Daniel Dunbar54423b22010-09-17 00:24:54 +00007023 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007024
Alexey Samsonov7811d192014-02-20 13:57:37 +00007025 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007026
Chris Lattner3e2ee142010-07-07 16:01:42 +00007027 if (!Args.hasArg(options::OPT_nostdlib) &&
7028 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007029 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007030 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007031 CmdArgs.push_back("-lm");
7032 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007033 }
7034
7035 if (!Args.hasArg(options::OPT_nostdlib) &&
7036 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007037 if (Args.hasArg(options::OPT_pthread))
7038 CmdArgs.push_back("-lpthread");
7039 CmdArgs.push_back("-lc");
7040 CmdArgs.push_back("-lCompilerRT-Generic");
7041 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7042 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007043 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007044 }
7045
Rafael Espindola236db462013-11-09 20:07:19 +00007046 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007047 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007048}
7049
Daniel Dunbarcc912342009-05-02 18:28:39 +00007050/// DragonFly Tools
7051
7052// For now, DragonFly Assemble does just about the same as for
7053// FreeBSD, but this may change soon.
7054void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007055 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007056 const InputInfoList &Inputs,
7057 const ArgList &Args,
7058 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007059 ArgStringList CmdArgs;
7060
7061 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7062 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007063 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007064 CmdArgs.push_back("--32");
7065
7066 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7067 options::OPT_Xassembler);
7068
7069 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007070 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007071
7072 for (InputInfoList::const_iterator
7073 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7074 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007075 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007076 }
7077
7078 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007079 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007080 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007081}
7082
7083void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007084 const InputInfo &Output,
7085 const InputInfoList &Inputs,
7086 const ArgList &Args,
7087 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007088 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007089 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007090 ArgStringList CmdArgs;
7091
John McCall65b8da02013-04-11 22:55:55 +00007092 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7093 UseGCC47 = false;
7094
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007095 if (!D.SysRoot.empty())
7096 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7097
John McCall65b8da02013-04-11 22:55:55 +00007098 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007099 if (Args.hasArg(options::OPT_static)) {
7100 CmdArgs.push_back("-Bstatic");
7101 } else {
John McCall65b8da02013-04-11 22:55:55 +00007102 if (Args.hasArg(options::OPT_rdynamic))
7103 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007104 if (Args.hasArg(options::OPT_shared))
7105 CmdArgs.push_back("-Bshareable");
7106 else {
7107 CmdArgs.push_back("-dynamic-linker");
7108 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7109 }
John McCall65b8da02013-04-11 22:55:55 +00007110 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007111 }
7112
7113 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7114 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007115 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007116 CmdArgs.push_back("-m");
7117 CmdArgs.push_back("elf_i386");
7118 }
7119
Daniel Dunbarb440f562010-08-02 02:38:21 +00007120 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007121 CmdArgs.push_back("-o");
7122 CmdArgs.push_back(Output.getFilename());
7123 } else {
7124 assert(Output.isNothing() && "Invalid output.");
7125 }
7126
7127 if (!Args.hasArg(options::OPT_nostdlib) &&
7128 !Args.hasArg(options::OPT_nostartfiles)) {
7129 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007130 if (Args.hasArg(options::OPT_pg))
7131 CmdArgs.push_back(Args.MakeArgString(
7132 getToolChain().GetFilePath("gcrt1.o")));
7133 else {
7134 if (Args.hasArg(options::OPT_pie))
7135 CmdArgs.push_back(Args.MakeArgString(
7136 getToolChain().GetFilePath("Scrt1.o")));
7137 else
7138 CmdArgs.push_back(Args.MakeArgString(
7139 getToolChain().GetFilePath("crt1.o")));
7140 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007141 }
John McCall65b8da02013-04-11 22:55:55 +00007142 CmdArgs.push_back(Args.MakeArgString(
7143 getToolChain().GetFilePath("crti.o")));
7144 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7145 CmdArgs.push_back(Args.MakeArgString(
7146 getToolChain().GetFilePath("crtbeginS.o")));
7147 else
7148 CmdArgs.push_back(Args.MakeArgString(
7149 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007150 }
7151
7152 Args.AddAllArgs(CmdArgs, options::OPT_L);
7153 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7154 Args.AddAllArgs(CmdArgs, options::OPT_e);
7155
Daniel Dunbar54423b22010-09-17 00:24:54 +00007156 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007157
7158 if (!Args.hasArg(options::OPT_nostdlib) &&
7159 !Args.hasArg(options::OPT_nodefaultlibs)) {
7160 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7161 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007162 if (UseGCC47)
7163 CmdArgs.push_back("-L/usr/lib/gcc47");
7164 else
7165 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007166
7167 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007168 if (UseGCC47) {
7169 CmdArgs.push_back("-rpath");
7170 CmdArgs.push_back("/usr/lib/gcc47");
7171 } else {
7172 CmdArgs.push_back("-rpath");
7173 CmdArgs.push_back("/usr/lib/gcc44");
7174 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007175 }
7176
Hans Wennborg70850d82013-07-18 20:29:38 +00007177 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007178 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007179 CmdArgs.push_back("-lm");
7180 }
7181
Daniel Dunbarcc912342009-05-02 18:28:39 +00007182 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007183 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007184
7185 if (!Args.hasArg(options::OPT_nolibc)) {
7186 CmdArgs.push_back("-lc");
7187 }
7188
John McCall65b8da02013-04-11 22:55:55 +00007189 if (UseGCC47) {
7190 if (Args.hasArg(options::OPT_static) ||
7191 Args.hasArg(options::OPT_static_libgcc)) {
7192 CmdArgs.push_back("-lgcc");
7193 CmdArgs.push_back("-lgcc_eh");
7194 } else {
7195 if (Args.hasArg(options::OPT_shared_libgcc)) {
7196 CmdArgs.push_back("-lgcc_pic");
7197 if (!Args.hasArg(options::OPT_shared))
7198 CmdArgs.push_back("-lgcc");
7199 } else {
7200 CmdArgs.push_back("-lgcc");
7201 CmdArgs.push_back("--as-needed");
7202 CmdArgs.push_back("-lgcc_pic");
7203 CmdArgs.push_back("--no-as-needed");
7204 }
7205 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007206 } else {
John McCall65b8da02013-04-11 22:55:55 +00007207 if (Args.hasArg(options::OPT_shared)) {
7208 CmdArgs.push_back("-lgcc_pic");
7209 } else {
7210 CmdArgs.push_back("-lgcc");
7211 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007212 }
7213 }
7214
7215 if (!Args.hasArg(options::OPT_nostdlib) &&
7216 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007217 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007218 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007219 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007220 else
7221 CmdArgs.push_back(Args.MakeArgString(
7222 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007223 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007224 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007225 }
7226
Alexey Samsonov7811d192014-02-20 13:57:37 +00007227 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007228
Daniel Dunbarcc912342009-05-02 18:28:39 +00007229 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00007230 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007231 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007232}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007233
7234void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7235 const InputInfo &Output,
7236 const InputInfoList &Inputs,
7237 const ArgList &Args,
7238 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007239 ArgStringList CmdArgs;
7240
7241 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007242 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7243 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007244 } else {
7245 assert(Output.isNothing() && "Invalid output.");
7246 }
7247
7248 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007249 !Args.hasArg(options::OPT_nostartfiles) &&
7250 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007251 CmdArgs.push_back("-defaultlib:libcmt");
7252 }
7253
7254 CmdArgs.push_back("-nologo");
7255
Hans Wennborgf1a74252013-09-10 20:18:04 +00007256 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7257
7258 if (DLL) {
7259 CmdArgs.push_back(Args.MakeArgString("-dll"));
7260
7261 SmallString<128> ImplibName(Output.getFilename());
7262 llvm::sys::path::replace_extension(ImplibName, "lib");
7263 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7264 ImplibName.str()));
7265 }
7266
Peter Collingbourne32701642013-11-01 18:16:25 +00007267 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007268 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007269 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborg65f17522013-08-27 18:10:21 +00007270 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007271 llvm::sys::path::append(LibSanitizer, "lib", "windows");
7272 if (DLL) {
Timur Iskhodzhanov3b6adcb62013-09-11 11:45:31 +00007273 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
Hans Wennborgf1a74252013-09-10 20:18:04 +00007274 } else {
7275 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
7276 }
7277 // FIXME: Handle 64-bit.
Hans Wennborg65f17522013-08-27 18:10:21 +00007278 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7279 }
7280
Michael J. Spencere2f49362012-06-18 16:56:04 +00007281 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007282 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007283
7284 // Add filenames immediately.
7285 for (InputInfoList::const_iterator
7286 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7287 if (it->isFilename())
7288 CmdArgs.push_back(it->getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007289 else
7290 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007291 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007292
7293 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007294 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007295 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7296}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007297
7298void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7299 const InputInfo &Output,
7300 const InputInfoList &Inputs,
7301 const ArgList &Args,
7302 const char *LinkingOutput) const {
7303 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7304}
7305
Hans Wennborg188382e2013-09-20 18:16:35 +00007306// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7307// If one cannot be found, return FallbackName.
7308// We do this special search to prevent clang-cl from falling back onto itself
7309// if it's available as cl.exe on the path.
7310static std::string FindFallback(const char *FallbackName,
7311 const char *ClangProgramPath) {
7312 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7313 if (!OptPath.hasValue())
7314 return FallbackName;
7315
7316#ifdef LLVM_ON_WIN32
7317 const StringRef PathSeparators = ";";
7318#else
7319 const StringRef PathSeparators = ":";
7320#endif
7321
7322 SmallVector<StringRef, 8> PathSegments;
7323 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7324
7325 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7326 const StringRef &PathSegment = PathSegments[i];
7327 if (PathSegment.empty())
7328 continue;
7329
7330 SmallString<128> FilePath(PathSegment);
7331 llvm::sys::path::append(FilePath, FallbackName);
7332 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7333 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7334 return FilePath.str();
7335 }
7336
7337 return FallbackName;
7338}
7339
Hans Wennborg87cfa712013-09-19 20:32:16 +00007340Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7341 const InputInfo &Output,
7342 const InputInfoList &Inputs,
7343 const ArgList &Args,
7344 const char *LinkingOutput) const {
7345 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007346 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007347 CmdArgs.push_back("/c"); // Compile only.
7348 CmdArgs.push_back("/W0"); // No warnings.
7349
7350 // The goal is to be able to invoke this tool correctly based on
7351 // any flag accepted by clang-cl.
7352
7353 // These are spelled the same way in clang and cl.exe,.
7354 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7355 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007356
7357 // Optimization level.
7358 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7359 if (A->getOption().getID() == options::OPT_O0) {
7360 CmdArgs.push_back("/Od");
7361 } else {
7362 StringRef OptLevel = A->getValue();
7363 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7364 A->render(Args, CmdArgs);
7365 else if (OptLevel == "3")
7366 CmdArgs.push_back("/Ox");
7367 }
7368 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007369
7370 // Flags for which clang-cl have an alias.
7371 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7372
7373 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7374 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7375 : "/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007376 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7377 options::OPT_fno_function_sections))
7378 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7379 ? "/Gy"
7380 : "/Gy-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007381 if (Args.hasArg(options::OPT_fsyntax_only))
7382 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007383 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7384 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007385
Hans Wennborg260ff402013-09-27 17:54:18 +00007386 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7387 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7388 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7389
Hans Wennborg87cfa712013-09-19 20:32:16 +00007390 // Flags that can simply be passed through.
7391 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7392 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7393
7394 // The order of these flags is relevant, so pick the last one.
7395 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7396 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7397 A->render(Args, CmdArgs);
7398
7399
7400 // Input filename.
7401 assert(Inputs.size() == 1);
7402 const InputInfo &II = Inputs[0];
7403 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7404 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7405 if (II.isFilename())
7406 CmdArgs.push_back(II.getFilename());
7407 else
7408 II.getInputArg().renderAsInput(Args, CmdArgs);
7409
7410 // Output filename.
7411 assert(Output.getType() == types::TY_Object);
7412 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7413 Output.getFilename());
7414 CmdArgs.push_back(Fo);
7415
Hans Wennborg188382e2013-09-20 18:16:35 +00007416 const Driver &D = getToolChain().getDriver();
7417 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg87cfa712013-09-19 20:32:16 +00007418
Hans Wennborg188382e2013-09-20 18:16:35 +00007419 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007420}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007421
7422
7423/// XCore Tools
7424// We pass assemble and link construction to the xcc tool.
7425
7426void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7427 const InputInfo &Output,
7428 const InputInfoList &Inputs,
7429 const ArgList &Args,
7430 const char *LinkingOutput) const {
7431 ArgStringList CmdArgs;
7432
7433 CmdArgs.push_back("-o");
7434 CmdArgs.push_back(Output.getFilename());
7435
7436 CmdArgs.push_back("-c");
7437
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007438 if (Args.hasArg(options::OPT_v))
7439 CmdArgs.push_back("-v");
7440
7441 if (Args.hasArg(options::OPT_g_Group))
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007442 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007443
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007444 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7445 false))
7446 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007447
7448 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7449 options::OPT_Xassembler);
7450
7451 for (InputInfoList::const_iterator
7452 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7453 const InputInfo &II = *it;
7454 CmdArgs.push_back(II.getFilename());
7455 }
7456
7457 const char *Exec =
7458 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7459 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7460}
7461
7462void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7463 const InputInfo &Output,
7464 const InputInfoList &Inputs,
7465 const ArgList &Args,
7466 const char *LinkingOutput) const {
7467 ArgStringList CmdArgs;
7468
7469 if (Output.isFilename()) {
7470 CmdArgs.push_back("-o");
7471 CmdArgs.push_back(Output.getFilename());
7472 } else {
7473 assert(Output.isNothing() && "Invalid output.");
7474 }
7475
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007476 if (Args.hasArg(options::OPT_v))
7477 CmdArgs.push_back("-v");
7478
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007479 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7480 if (EH.ShouldUseExceptionTables)
7481 CmdArgs.push_back("-fexceptions");
7482
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007483 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7484
7485 const char *Exec =
7486 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7487 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7488}