blob: 756815147c6e331956a84608c461886af88b864f [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000011#include "InputInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000012#include "ToolChains.h"
Josh Mageee0fc1a82014-02-11 01:35:14 +000013#include "clang/Basic/LangOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "clang/Basic/ObjCRuntime.h"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000015#include "clang/Basic/Version.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000016#include "clang/Driver/Action.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000018#include "clang/Driver/Driver.h"
19#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000020#include "clang/Driver/Job.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000021#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000022#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000023#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000024#include "clang/Driver/Util.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000026#include "llvm/ADT/StringExtras.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000027#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000028#include "llvm/ADT/Twine.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000029#include "llvm/Option/Arg.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Option/Option.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000032#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000033#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000034#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000035#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000036#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000037#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000038#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000039#include "llvm/Support/raw_ostream.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000040#include <sys/stat.h>
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000041
Daniel Dunbar1a093d22009-03-18 06:00:36 +000042using namespace clang::driver;
43using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000044using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000045using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000046
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000047static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
48 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
49 options::OPT_fpic, options::OPT_fno_pic,
50 options::OPT_fPIE, options::OPT_fno_PIE,
51 options::OPT_fpie, options::OPT_fno_pie);
52 if (!LastPICArg)
53 return;
54 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
55 LastPICArg->getOption().matches(options::OPT_fpic) ||
56 LastPICArg->getOption().matches(options::OPT_fPIE) ||
57 LastPICArg->getOption().matches(options::OPT_fpie)) {
58 CmdArgs.push_back("-KPIC");
59 }
60}
61
Daniel Dunbar64198ef2009-09-10 01:21:05 +000062/// CheckPreprocessingOptions - Perform some validation of preprocessing
63/// arguments that is shared with gcc.
64static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
65 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Hans Wennborg70850d82013-07-18 20:29:38 +000066 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
Chris Lattner0e62c1c2011-07-23 10:55:15 +000067 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar64198ef2009-09-10 01:21:05 +000068 << A->getAsString(Args) << "-E";
69}
70
Daniel Dunbar4eadb602009-09-10 01:21:12 +000071/// CheckCodeGenerationOptions - Perform some validation of code generation
72/// arguments that is shared with gcc.
73static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
74 // In gcc, only ARM checks this, but it seems reasonable to check universally.
75 if (Args.hasArg(options::OPT_static))
76 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
77 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000078 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000079 << A->getAsString(Args) << "-static";
80}
81
Chris Lattnerbf2803f2010-03-29 17:55:58 +000082// Quote target names for inclusion in GNU Make dependency files.
83// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000084static void QuoteTarget(StringRef Target,
85 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000086 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
87 switch (Target[i]) {
88 case ' ':
89 case '\t':
90 // Escape the preceding backslashes
91 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
92 Res.push_back('\\');
93
94 // Escape the space/tab
95 Res.push_back('\\');
96 break;
97 case '$':
98 Res.push_back('$');
99 break;
100 case '#':
101 Res.push_back('\\');
102 break;
103 default:
104 break;
105 }
106
107 Res.push_back(Target[i]);
108 }
109}
110
Bill Wendlingc0938f32012-03-12 22:10:06 +0000111static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000112 ArgStringList &CmdArgs,
113 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000114 const char *EnvVar) {
115 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000116 bool CombinedArg = false;
117
Bill Wendling281ca292012-03-12 21:22:35 +0000118 if (!DirList)
119 return; // Nothing to do.
120
Chad Rosier616e8a52012-10-30 21:42:09 +0000121 StringRef Name(ArgName);
122 if (Name.equals("-I") || Name.equals("-L"))
123 CombinedArg = true;
124
Bill Wendling281ca292012-03-12 21:22:35 +0000125 StringRef Dirs(DirList);
126 if (Dirs.empty()) // Empty string should not add '.'.
127 return;
128
129 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000130 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000131 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000132 if (CombinedArg) {
133 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
134 } else {
135 CmdArgs.push_back(ArgName);
136 CmdArgs.push_back(".");
137 }
Bill Wendling281ca292012-03-12 21:22:35 +0000138 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000139 if (CombinedArg) {
140 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
141 } else {
142 CmdArgs.push_back(ArgName);
143 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
144 }
Bill Wendling281ca292012-03-12 21:22:35 +0000145 }
Nico Weber89355782012-03-19 15:00:03 +0000146 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000147 }
148
149 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000150 if (CombinedArg) {
151 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
152 } else {
153 CmdArgs.push_back(ArgName);
154 CmdArgs.push_back(".");
155 }
Bill Wendling281ca292012-03-12 21:22:35 +0000156 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000157 if (CombinedArg) {
158 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
159 } else {
160 CmdArgs.push_back(ArgName);
161 CmdArgs.push_back(Args.MakeArgString(Dirs));
162 }
Bill Wendling281ca292012-03-12 21:22:35 +0000163 }
164}
165
Daniel Dunbar54423b22010-09-17 00:24:54 +0000166static void AddLinkerInputs(const ToolChain &TC,
167 const InputInfoList &Inputs, const ArgList &Args,
168 ArgStringList &CmdArgs) {
169 const Driver &D = TC.getDriver();
170
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000171 // Add extra linker input arguments which are not treated as inputs
172 // (constructed via -Xarch_).
173 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
174
Daniel Dunbar54423b22010-09-17 00:24:54 +0000175 for (InputInfoList::const_iterator
176 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
177 const InputInfo &II = *it;
178
179 if (!TC.HasNativeLLVMSupport()) {
180 // Don't try to pass LLVM inputs unless we have native support.
181 if (II.getType() == types::TY_LLVM_IR ||
182 II.getType() == types::TY_LTO_IR ||
183 II.getType() == types::TY_LLVM_BC ||
184 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000185 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000186 << TC.getTripleString();
187 }
188
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000189 // Add filenames immediately.
190 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000191 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000192 continue;
193 }
194
195 // Otherwise, this is a linker input argument.
196 const Arg &A = II.getInputArg();
197
198 // Handle reserved library options.
199 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000200 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000201 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
202 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000203 } else
204 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000205 }
Bill Wendling281ca292012-03-12 21:22:35 +0000206
207 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000208 // and only supported on native toolchains.
209 if (!TC.isCrossCompiling())
210 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000211}
212
John McCall31168b02011-06-15 23:02:42 +0000213/// \brief Determine whether Objective-C automated reference counting is
214/// enabled.
215static bool isObjCAutoRefCount(const ArgList &Args) {
216 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
217}
218
Ted Kremeneke65b0862012-03-06 20:05:56 +0000219/// \brief Determine whether we are linking the ObjC runtime.
220static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000221 if (isObjCAutoRefCount(Args)) {
222 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000223 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000224 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000225 return Args.hasArg(options::OPT_fobjc_link_runtime);
226}
227
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000228static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000229 // Don't forward inputs from the original command line. They are added from
230 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000231 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000232 !O.hasFlag(options::DriverOption) &&
233 !O.hasFlag(options::LinkerInput);
234}
235
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000236void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000237 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000238 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000239 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000240 ArgStringList &CmdArgs,
241 const InputInfo &Output,
242 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000243 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000244
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000245 CheckPreprocessingOptions(D, Args);
246
247 Args.AddLastArg(CmdArgs, options::OPT_C);
248 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000249
250 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000251 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000252 (A = Args.getLastArg(options::OPT_MD)) ||
253 (A = Args.getLastArg(options::OPT_MMD))) {
254 // Determine the output location.
255 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000256 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000257 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000258 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000259 } else if (Output.getType() == types::TY_Dependencies) {
260 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000261 } else if (A->getOption().matches(options::OPT_M) ||
262 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000263 DepFile = "-";
264 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000265 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000266 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000267 }
268 CmdArgs.push_back("-dependency-file");
269 CmdArgs.push_back(DepFile);
270
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000271 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000272 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
273 const char *DepTarget;
274
275 // If user provided -o, that is the dependency target, except
276 // when we are only generating a dependency file.
277 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
278 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000279 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000280 } else {
281 // Otherwise derive from the base input.
282 //
283 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000284 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000285 llvm::sys::path::replace_extension(P, "o");
286 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000287 }
288
289 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000290 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000291 QuoteTarget(DepTarget, Quoted);
292 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000293 }
294
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000295 if (A->getOption().matches(options::OPT_M) ||
296 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000297 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000298
299 if (isa<PrecompileJobAction>(JA))
300 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000301 }
302
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000303 if (Args.hasArg(options::OPT_MG)) {
304 if (!A || A->getOption().matches(options::OPT_MD) ||
305 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000306 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000307 CmdArgs.push_back("-MG");
308 }
309
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000310 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000311
312 // Convert all -MQ <target> args to -MT <quoted target>
313 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
314 options::OPT_MQ),
315 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000316 const Arg *A = *it;
317 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000318
Daniel Dunbara442fd52010-06-11 22:00:13 +0000319 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000320 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000321 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000322 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000323 CmdArgs.push_back(Args.MakeArgString(Quoted));
324
325 // -MT flag - no change
326 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000327 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000328 }
329 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000330
Douglas Gregor111af7d2009-04-18 00:34:01 +0000331 // Add -i* options, and automatically translate to
332 // -include-pch/-include-pth for transparent PCH support. It's
333 // wonky, but we include looking for .gch so we can support seamless
334 // replacement into a build system already set up to be generating
335 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000336 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000337 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
338 ie = Args.filtered_end(); it != ie; ++it) {
339 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000340
341 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000342 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
343 RenderedImplicitInclude = true;
344
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000345 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000346 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000347
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000348 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000349 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000350 SmallString<128> P(A->getValue());
351 // We want the files to have a name like foo.h.pch. Add a dummy extension
352 // so that replace_extension does the right thing.
353 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000354 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000355 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000356 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000357 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000358 }
359
Douglas Gregor111af7d2009-04-18 00:34:01 +0000360 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000361 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000362 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000363 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000364 }
365
Douglas Gregor111af7d2009-04-18 00:34:01 +0000366 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000367 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000368 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000369 FoundPCH = UsePCH;
370 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000371 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000372 }
373
374 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000375 if (IsFirstImplicitInclude) {
376 A->claim();
377 if (UsePCH)
378 CmdArgs.push_back("-include-pch");
379 else
380 CmdArgs.push_back("-include-pth");
381 CmdArgs.push_back(Args.MakeArgString(P.str()));
382 continue;
383 } else {
384 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000385 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000386 << P.str() << A->getAsString(Args);
387 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000388 }
389 }
390
391 // Not translated, render as usual.
392 A->claim();
393 A->render(Args, CmdArgs);
394 }
395
396 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000397 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
398 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000399
400 // Add -Wp, and -Xassembler if using the preprocessor.
401
402 // FIXME: There is a very unfortunate problem here, some troubled
403 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
404 // really support that we would have to parse and then translate
405 // those options. :(
406 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
407 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000408
409 // -I- is a deprecated GCC feature, reject it.
410 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000411 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000412
413 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
414 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000415 StringRef sysroot = C.getSysRoot();
416 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000417 if (!Args.hasArg(options::OPT_isysroot)) {
418 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000419 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000420 }
421 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000422
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000423 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000424 // FIXME: We should probably sink the logic for handling these from the
425 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000426 // CPATH - included following the user specified includes (but prior to
427 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000428 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000429 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000430 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000431 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000432 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000433 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000434 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000435 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000436 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000437
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000438 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000439 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000440 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000441
442 // Add system include arguments.
443 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000444}
445
Amara Emerson703da2e2013-10-31 09:32:33 +0000446/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting.
447//
448// FIXME: tblgen this.
449static std::string getAArch64TargetCPU(const ArgList &Args,
450 const llvm::Triple &Triple) {
451 // FIXME: Warn on inconsistent use of -mcpu and -march.
452
453 // If we have -mcpu=, use that.
454 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
455 StringRef MCPU = A->getValue();
456 // Handle -mcpu=native.
457 if (MCPU == "native")
458 return llvm::sys::getHostCPUName();
459 else
460 return MCPU;
461 }
462
463 return "generic";
464}
465
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000466// FIXME: Move to target hook.
467static bool isSignedCharDefault(const llvm::Triple &Triple) {
468 switch (Triple.getArch()) {
469 default:
470 return true;
471
Tim Northover9bb857a2013-01-31 12:13:10 +0000472 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000473 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000474 case llvm::Triple::arm:
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000475 case llvm::Triple::ppc:
476 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000477 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000478 return true;
479 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000480
Bill Schmidt778d3872013-07-26 01:36:11 +0000481 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000482 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000483 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000484 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000485 }
486}
487
Robert Lytton0e076492013-08-13 09:43:10 +0000488static bool isNoCommonDefault(const llvm::Triple &Triple) {
489 switch (Triple.getArch()) {
490 default:
491 return false;
492
493 case llvm::Triple::xcore:
494 return true;
495 }
496}
497
Chad Rosiercfbfc582012-04-04 20:51:35 +0000498// Handle -mfpu=.
499//
500// FIXME: Centralize feature selection, defaulting shouldn't be also in the
501// frontend target.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000502static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
503 const ArgList &Args,
504 std::vector<const char *> &Features) {
505 StringRef FPU = A->getValue();
506 if (FPU == "fp-armv8") {
507 Features.push_back("+fp-armv8");
508 } else if (FPU == "neon-fp-armv8") {
509 Features.push_back("+fp-armv8");
510 Features.push_back("+neon");
511 } else if (FPU == "crypto-neon-fp-armv8") {
512 Features.push_back("+fp-armv8");
513 Features.push_back("+neon");
514 Features.push_back("+crypto");
515 } else if (FPU == "neon") {
516 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000517 } else
518 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
519}
520
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000521// Handle -mhwdiv=.
522static void getARMHWDivFeatures(const Driver &D, const Arg *A,
523 const ArgList &Args,
524 std::vector<const char *> &Features) {
525 StringRef HWDiv = A->getValue();
526 if (HWDiv == "arm") {
527 Features.push_back("+hwdiv-arm");
528 Features.push_back("-hwdiv");
529 } else if (HWDiv == "thumb") {
530 Features.push_back("-hwdiv-arm");
531 Features.push_back("+hwdiv");
532 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
533 Features.push_back("+hwdiv-arm");
534 Features.push_back("+hwdiv");
535 } else if (HWDiv == "none") {
536 Features.push_back("-hwdiv-arm");
537 Features.push_back("-hwdiv");
538 } else
539 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
540}
541
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000542// Handle -mfpu=.
543//
544// FIXME: Centralize feature selection, defaulting shouldn't be also in the
545// frontend target.
546static void getARMFPUFeatures(const Driver &D, const Arg *A,
547 const ArgList &Args,
548 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000549 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000550
551 // Set the target features based on the FPU.
552 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
553 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000554 Features.push_back("-vfp2");
555 Features.push_back("-vfp3");
556 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000557 } else if (FPU == "vfp") {
558 Features.push_back("+vfp2");
559 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000560 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000561 Features.push_back("+vfp3");
562 Features.push_back("+d16");
563 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000564 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000565 Features.push_back("+vfp3");
566 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000567 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
568 Features.push_back("+vfp4");
569 Features.push_back("+d16");
570 Features.push_back("-neon");
571 } else if (FPU == "vfp4" || FPU == "vfpv4") {
572 Features.push_back("+vfp4");
573 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000574 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
575 Features.push_back("+vfp4");
576 Features.push_back("+d16");
577 Features.push_back("+fp-only-sp");
578 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000579 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000580 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000581 Features.push_back("-neon");
582 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000583 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000584 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000585 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000586 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000587 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000588 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000589 Features.push_back("+neon");
590 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000591 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000592 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000593 } else if (FPU == "none") {
594 Features.push_back("-vfp2");
595 Features.push_back("-vfp3");
596 Features.push_back("-vfp4");
597 Features.push_back("-fp-armv8");
598 Features.push_back("-crypto");
599 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000600 } else
601 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
602}
603
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000604// Select the float ABI as determined by -msoft-float, -mhard-float, and
605// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000606StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
607 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000608 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000609 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
610 options::OPT_mhard_float,
611 options::OPT_mfloat_abi_EQ)) {
612 if (A->getOption().matches(options::OPT_msoft_float))
613 FloatABI = "soft";
614 else if (A->getOption().matches(options::OPT_mhard_float))
615 FloatABI = "hard";
616 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000617 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000618 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000619 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000620 << A->getAsString(Args);
621 FloatABI = "soft";
622 }
623 }
624 }
625
626 // If unspecified, choose the default based on the platform.
627 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000628 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000629 case llvm::Triple::Darwin:
630 case llvm::Triple::MacOSX:
631 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000632 // Darwin defaults to "softfp" for v6 and v7.
633 //
634 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000635 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000636 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000637 if (StringRef(ArchName).startswith("v6") ||
638 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000639 FloatABI = "softfp";
640 else
641 FloatABI = "soft";
642 break;
643 }
644
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000645 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000646 switch(Triple.getEnvironment()) {
647 case llvm::Triple::GNUEABIHF:
648 FloatABI = "hard";
649 break;
650 default:
651 // FreeBSD defaults to soft float
652 FloatABI = "soft";
653 break;
654 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000655 break;
656
Daniel Dunbar78485922009-09-10 23:00:09 +0000657 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000658 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000659 case llvm::Triple::GNUEABIHF:
660 FloatABI = "hard";
661 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000662 case llvm::Triple::GNUEABI:
663 FloatABI = "softfp";
664 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000665 case llvm::Triple::EABIHF:
666 FloatABI = "hard";
667 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000668 case llvm::Triple::EABI:
669 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
670 FloatABI = "softfp";
671 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000672 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000673 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000674 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000675 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000676 FloatABI = "softfp";
677 else
678 FloatABI = "soft";
679 break;
680 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000681 default:
682 // Assume "soft", but warn the user we are guessing.
683 FloatABI = "soft";
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000684 // *-macho defaults to "soft"
685 if (Triple.getOS() == llvm::Triple::UnknownOS &&
686 Triple.getObjectFormat() == llvm::Triple::MachO)
687 break;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000688 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000689 break;
690 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000691 }
692 }
693
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000694 return FloatABI;
695}
696
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000697static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
698 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000699 std::vector<const char *> &Features,
700 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000701 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000702 if (!ForAS) {
703 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
704 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
705 // stripped out by the ARM target. We should probably pass this a new
706 // -target-option, which is handled by the -cc1/-cc1as invocation.
707 //
708 // FIXME2: For consistency, it would be ideal if we set up the target
709 // machine state the same when using the frontend or the assembler. We don't
710 // currently do that for the assembler, we pass the options directly to the
711 // backend and never even instantiate the frontend TargetInfo. If we did,
712 // and used its handleTargetFeatures hook, then we could ensure the
713 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000714
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000715 // Use software floating point operations?
716 if (FloatABI == "soft")
717 Features.push_back("+soft-float");
718
719 // Use software floating point argument passing?
720 if (FloatABI != "hard")
721 Features.push_back("+soft-float-abi");
722 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000723
724 // Honor -mfpu=.
725 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000726 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000727 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
728 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000729
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000730 // Setting -msoft-float effectively disables NEON because of the GCC
731 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000732 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000733 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000734 // Also need to explicitly disable features which imply NEON.
735 Features.push_back("-crypto");
736 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000737
738 // En/disable crc
739 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
740 options::OPT_mnocrc)) {
741 if (A->getOption().matches(options::OPT_mcrc))
742 Features.push_back("+crc");
743 else
744 Features.push_back("-crc");
745 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000746}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000747
748void Clang::AddARMTargetArgs(const ArgList &Args,
749 ArgStringList &CmdArgs,
750 bool KernelOrKext) const {
751 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000752 // Get the effective triple, which takes into account the deployment target.
753 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
754 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000755 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000756
757 // Select the ABI to use.
758 //
759 // FIXME: Support -meabi.
760 const char *ABIName = 0;
761 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000762 ABIName = A->getValue();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000763 } else if (Triple.isOSDarwin()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000764 // The backend is hardwired to assume AAPCS for M-class processors, ensure
765 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000766 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000767 (Triple.getOS() == llvm::Triple::UnknownOS &&
768 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000769 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000770 ABIName = "aapcs";
771 } else {
772 ABIName = "apcs-gnu";
773 }
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000774 } else {
775 // Select the default based on the platform.
776 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000777 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000778 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000779 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000780 ABIName = "aapcs-linux";
781 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000782 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000783 case llvm::Triple::EABI:
784 ABIName = "aapcs";
785 break;
786 default:
787 ABIName = "apcs-gnu";
788 }
789 }
790 CmdArgs.push_back("-target-abi");
791 CmdArgs.push_back(ABIName);
792
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000793 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000794 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000795 if (FloatABI == "soft") {
796 // Floating point operations and argument passing are soft.
797 //
798 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000799 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000800 CmdArgs.push_back("-mfloat-abi");
801 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000802 } else if (FloatABI == "softfp") {
803 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000804 CmdArgs.push_back("-mfloat-abi");
805 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000806 } else {
807 // Floating point operations and argument passing are hard.
808 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000809 CmdArgs.push_back("-mfloat-abi");
810 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000811 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000812
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000813 // Kernel code has more strict alignment requirements.
814 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000815 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000816 CmdArgs.push_back("-backend-option");
817 CmdArgs.push_back("-arm-long-calls");
818 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000819
Daniel Dunbar12100e22011-03-22 16:48:17 +0000820 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000821 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000822
823 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000824 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000825 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000826 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000827
828 // Setting -mno-global-merge disables the codegen global merge pass. Setting
829 // -mglobal-merge has no effect as the pass is enabled by default.
830 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
831 options::OPT_mno_global_merge)) {
832 if (A->getOption().matches(options::OPT_mno_global_merge))
833 CmdArgs.push_back("-mno-global-merge");
834 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000835
Bob Wilson9c8af452013-04-11 18:53:25 +0000836 if (!Args.hasFlag(options::OPT_mimplicit_float,
837 options::OPT_mno_implicit_float,
838 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000839 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000840
841 // llvm does not support reserving registers in general. There is support
842 // for reserving r9 on ARM though (defined as a platform-specific register
843 // in ARM EABI).
844 if (Args.hasArg(options::OPT_ffixed_r9)) {
845 CmdArgs.push_back("-backend-option");
846 CmdArgs.push_back("-arm-reserve-r9");
847 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000848}
849
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000850// Get CPU and ABI names. They are not independent
851// so we have to calculate them together.
852static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000853 const llvm::Triple &Triple,
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000854 StringRef &CPUName,
855 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000856 const char *DefMips32CPU = "mips32r2";
857 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000858
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000859 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000860 options::OPT_mcpu_EQ))
861 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000862
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000863 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000864 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000865 // Convert a GNU style Mips ABI name to the name
866 // accepted by LLVM Mips backend.
867 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
868 .Case("32", "o32")
869 .Case("64", "n64")
870 .Default(ABIName);
871 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000872
873 // Setup default CPU and ABI names.
874 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000875 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000876 default:
877 llvm_unreachable("Unexpected triple arch name");
878 case llvm::Triple::mips:
879 case llvm::Triple::mipsel:
880 CPUName = DefMips32CPU;
881 break;
882 case llvm::Triple::mips64:
883 case llvm::Triple::mips64el:
884 CPUName = DefMips64CPU;
885 break;
886 }
887 }
888
889 if (!ABIName.empty()) {
890 // Deduce CPU name from ABI name.
891 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000892 .Cases("32", "o32", "eabi", DefMips32CPU)
893 .Cases("n32", "n64", "64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000894 .Default("");
895 }
896 else if (!CPUName.empty()) {
897 // Deduce ABI name from CPU name.
898 ABIName = llvm::StringSwitch<const char *>(CPUName)
899 .Cases("mips32", "mips32r2", "o32")
900 .Cases("mips64", "mips64r2", "n64")
901 .Default("");
902 }
903
904 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000905}
906
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000907// Convert ABI name to the GNU tools acceptable variant.
908static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
909 return llvm::StringSwitch<llvm::StringRef>(ABI)
910 .Case("o32", "32")
911 .Case("n64", "64")
912 .Default(ABI);
913}
914
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000915// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
916// and -mfloat-abi=.
917static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000918 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000919 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000920 options::OPT_mhard_float,
921 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000922 if (A->getOption().matches(options::OPT_msoft_float))
923 FloatABI = "soft";
924 else if (A->getOption().matches(options::OPT_mhard_float))
925 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000926 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000927 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000928 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000929 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000930 FloatABI = "hard";
931 }
932 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000933 }
934
935 // If unspecified, choose the default based on the platform.
936 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000937 // Assume "hard", because it's a default value used by gcc.
938 // When we start to recognize specific target MIPS processors,
939 // we will be able to select the default more correctly.
940 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000941 }
942
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000943 return FloatABI;
944}
945
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000946static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000947 std::vector<const char *> &Features,
948 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000949 StringRef FeatureName) {
950 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000951 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000952 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000953 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000954 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000955 }
956}
957
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000958static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
959 std::vector<const char *> &Features) {
960 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +0000961 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000962 // FIXME: Note, this is a hack. We need to pass the selected float
963 // mode to the MipsTargetInfoBase to define appropriate macros there.
964 // Now it is the only method.
965 Features.push_back("+soft-float");
966 }
967
Simon Atanasyan22127ce2013-09-24 09:09:16 +0000968 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
969 if (StringRef(A->getValue()) == "2008")
970 Features.push_back("+nan2008");
971 }
972
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000973 AddTargetFeature(Args, Features, options::OPT_msingle_float,
974 options::OPT_mdouble_float, "single-float");
975 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
976 "mips16");
977 AddTargetFeature(Args, Features, options::OPT_mmicromips,
978 options::OPT_mno_micromips, "micromips");
979 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
980 "dsp");
981 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
982 "dspr2");
983 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
984 "msa");
Daniel Sanders94694172013-10-17 14:55:58 +0000985 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
986 "fp64");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000987}
988
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000989void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +0000990 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000991 const Driver &D = getToolChain().getDriver();
992 StringRef CPUName;
993 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000994 const llvm::Triple &Triple = getToolChain().getTriple();
995 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000996
997 CmdArgs.push_back("-target-abi");
998 CmdArgs.push_back(ABIName.data());
999
1000 StringRef FloatABI = getMipsFloatABI(D, Args);
1001
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001002 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001003 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001004 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001005 CmdArgs.push_back("-mfloat-abi");
1006 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001007 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001008 else {
1009 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001010 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001011 CmdArgs.push_back("-mfloat-abi");
1012 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001013 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001014
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001015 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1016 if (A->getOption().matches(options::OPT_mxgot)) {
1017 CmdArgs.push_back("-mllvm");
1018 CmdArgs.push_back("-mxgot");
1019 }
1020 }
1021
Simon Atanasyanc580b322013-05-11 06:33:44 +00001022 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1023 options::OPT_mno_ldc1_sdc1)) {
1024 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1025 CmdArgs.push_back("-mllvm");
1026 CmdArgs.push_back("-mno-ldc1-sdc1");
1027 }
1028 }
1029
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001030 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1031 options::OPT_mno_check_zero_division)) {
1032 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1033 CmdArgs.push_back("-mllvm");
1034 CmdArgs.push_back("-mno-check-zero-division");
1035 }
1036 }
1037
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001038 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001039 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001040 CmdArgs.push_back("-mllvm");
1041 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1042 A->claim();
1043 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001044}
1045
Hal Finkel8eb59282012-06-11 22:35:19 +00001046/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1047static std::string getPPCTargetCPU(const ArgList &Args) {
1048 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001049 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001050
1051 if (CPUName == "native") {
1052 std::string CPU = llvm::sys::getHostCPUName();
1053 if (!CPU.empty() && CPU != "generic")
1054 return CPU;
1055 else
1056 return "";
1057 }
1058
1059 return llvm::StringSwitch<const char *>(CPUName)
1060 .Case("common", "generic")
1061 .Case("440", "440")
1062 .Case("440fp", "440")
1063 .Case("450", "450")
1064 .Case("601", "601")
1065 .Case("602", "602")
1066 .Case("603", "603")
1067 .Case("603e", "603e")
1068 .Case("603ev", "603ev")
1069 .Case("604", "604")
1070 .Case("604e", "604e")
1071 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001072 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001073 .Case("G3", "g3")
1074 .Case("7400", "7400")
1075 .Case("G4", "g4")
1076 .Case("7450", "7450")
1077 .Case("G4+", "g4+")
1078 .Case("750", "750")
1079 .Case("970", "970")
1080 .Case("G5", "g5")
1081 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001082 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001083 .Case("e500mc", "e500mc")
1084 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001085 .Case("power3", "pwr3")
1086 .Case("power4", "pwr4")
1087 .Case("power5", "pwr5")
1088 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001089 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001090 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001091 .Case("power7", "pwr7")
Bill Schmidt38378a02013-02-01 20:23:10 +00001092 .Case("pwr3", "pwr3")
1093 .Case("pwr4", "pwr4")
1094 .Case("pwr5", "pwr5")
1095 .Case("pwr5x", "pwr5x")
1096 .Case("pwr6", "pwr6")
1097 .Case("pwr6x", "pwr6x")
1098 .Case("pwr7", "pwr7")
Hal Finkel8eb59282012-06-11 22:35:19 +00001099 .Case("powerpc", "ppc")
1100 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001101 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001102 .Default("");
1103 }
1104
1105 return "";
1106}
1107
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001108static void getPPCTargetFeatures(const ArgList &Args,
1109 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001110 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1111 ie = Args.filtered_end();
1112 it != ie; ++it) {
1113 StringRef Name = (*it)->getOption().getName();
1114 (*it)->claim();
1115
1116 // Skip over "-m".
1117 assert(Name.startswith("m") && "Invalid feature name.");
1118 Name = Name.substr(1);
1119
1120 bool IsNegative = Name.startswith("no-");
1121 if (IsNegative)
1122 Name = Name.substr(3);
1123
1124 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1125 // pass the correct option to the backend while calling the frontend
1126 // option the same.
1127 // TODO: Change the LLVM backend option maybe?
1128 if (Name == "mfcrf")
1129 Name = "mfocrf";
1130
1131 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1132 }
1133
1134 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001135 AddTargetFeature(Args, Features, options::OPT_faltivec,
1136 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001137}
1138
Tom Stellard6674c702013-04-01 20:56:53 +00001139/// Get the (LLVM) name of the R600 gpu we are targeting.
1140static std::string getR600TargetGPU(const ArgList &Args) {
1141 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001142 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001143 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001144 .Cases("rv630", "rv635", "r600")
1145 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001146 .Case("rv740", "rv770")
1147 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001148 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001149 .Case("hemlock", "cypress")
1150 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001151 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001152 }
1153 return "";
1154}
1155
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001156static void getSparcTargetFeatures(const ArgList &Args,
1157 std::vector<const char *> Features) {
1158 bool SoftFloatABI = true;
1159 if (Arg *A =
1160 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1161 if (A->getOption().matches(options::OPT_mhard_float))
1162 SoftFloatABI = false;
1163 }
1164 if (SoftFloatABI)
1165 Features.push_back("+soft-float");
1166}
1167
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001168void Clang::AddSparcTargetArgs(const ArgList &Args,
1169 ArgStringList &CmdArgs) const {
1170 const Driver &D = getToolChain().getDriver();
1171
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001172 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001173 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001174 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1175 options::OPT_mhard_float)) {
1176 if (A->getOption().matches(options::OPT_msoft_float))
1177 FloatABI = "soft";
1178 else if (A->getOption().matches(options::OPT_mhard_float))
1179 FloatABI = "hard";
1180 }
1181
1182 // If unspecified, choose the default based on the platform.
1183 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001184 // Assume "soft", but warn the user we are guessing.
1185 FloatABI = "soft";
1186 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001187 }
1188
1189 if (FloatABI == "soft") {
1190 // Floating point operations and argument passing are soft.
1191 //
1192 // FIXME: This changes CPP defines, we need -target-soft-float.
1193 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001194 } else {
1195 assert(FloatABI == "hard" && "Invalid float abi!");
1196 CmdArgs.push_back("-mhard-float");
1197 }
1198}
1199
Richard Sandiford4652d892013-07-19 16:51:51 +00001200static const char *getSystemZTargetCPU(const ArgList &Args) {
1201 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1202 return A->getValue();
1203 return "z10";
1204}
1205
Chandler Carruth953fb082013-01-13 11:46:33 +00001206static const char *getX86TargetCPU(const ArgList &Args,
1207 const llvm::Triple &Triple) {
1208 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001209 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001210 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001211 return "core-avx2";
1212
Chandler Carruth953fb082013-01-13 11:46:33 +00001213 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001214 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001215
1216 // FIXME: Reject attempts to use -march=native unless the target matches
1217 // the host.
1218 //
1219 // FIXME: We should also incorporate the detected target features for use
1220 // with -native.
1221 std::string CPU = llvm::sys::getHostCPUName();
1222 if (!CPU.empty() && CPU != "generic")
1223 return Args.MakeArgString(CPU);
1224 }
1225
1226 // Select the default CPU if none was given (or detection failed).
1227
1228 if (Triple.getArch() != llvm::Triple::x86_64 &&
1229 Triple.getArch() != llvm::Triple::x86)
1230 return 0; // This routine is only handling x86 targets.
1231
1232 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1233
1234 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001235 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001236 if (Triple.getArchName() == "x86_64h")
1237 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001238 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001239 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001240
Alexey Bataev286d1b92014-01-31 04:07:13 +00001241 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001242 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001243 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001244
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001245 // Everything else goes to x86-64 in 64-bit mode.
1246 if (Is64Bit)
1247 return "x86-64";
1248
1249 switch (Triple.getOS()) {
1250 case llvm::Triple::FreeBSD:
1251 case llvm::Triple::NetBSD:
1252 case llvm::Triple::OpenBSD:
1253 return "i486";
1254 case llvm::Triple::Haiku:
1255 return "i586";
1256 case llvm::Triple::Bitrig:
1257 return "i686";
1258 default:
1259 // Fallback to p4.
1260 return "pentium4";
1261 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001262}
1263
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001264static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1265 switch(T.getArch()) {
1266 default:
1267 return "";
1268
Amara Emerson703da2e2013-10-31 09:32:33 +00001269 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001270 case llvm::Triple::aarch64_be:
Amara Emerson703da2e2013-10-31 09:32:33 +00001271 return getAArch64TargetCPU(Args, T);
1272
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001273 case llvm::Triple::arm:
1274 case llvm::Triple::thumb:
Bernard Ogden31561762013-12-12 13:27:11 +00001275 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001276
1277 case llvm::Triple::mips:
1278 case llvm::Triple::mipsel:
1279 case llvm::Triple::mips64:
1280 case llvm::Triple::mips64el: {
1281 StringRef CPUName;
1282 StringRef ABIName;
1283 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1284 return CPUName;
1285 }
1286
1287 case llvm::Triple::ppc:
1288 case llvm::Triple::ppc64:
1289 case llvm::Triple::ppc64le: {
1290 std::string TargetCPUName = getPPCTargetCPU(Args);
1291 // LLVM may default to generating code for the native CPU,
1292 // but, like gcc, we default to a more generic option for
1293 // each architecture. (except on Darwin)
1294 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1295 if (T.getArch() == llvm::Triple::ppc64)
1296 TargetCPUName = "ppc64";
1297 else if (T.getArch() == llvm::Triple::ppc64le)
1298 TargetCPUName = "ppc64le";
1299 else
1300 TargetCPUName = "ppc";
1301 }
1302 return TargetCPUName;
1303 }
1304
1305 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001306 case llvm::Triple::sparcv9:
1307 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001308 return A->getValue();
1309 return "";
1310
1311 case llvm::Triple::x86:
1312 case llvm::Triple::x86_64:
1313 return getX86TargetCPU(Args, T);
1314
1315 case llvm::Triple::hexagon:
1316 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1317
1318 case llvm::Triple::systemz:
1319 return getSystemZTargetCPU(Args);
1320
1321 case llvm::Triple::r600:
1322 return getR600TargetGPU(Args);
1323 }
1324}
1325
Alp Tokerce365ca2013-12-02 12:43:03 +00001326static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1327 ArgStringList &CmdArgs) {
1328 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1329 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1330 // forward.
1331 CmdArgs.push_back("-plugin");
1332 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1333 CmdArgs.push_back(Args.MakeArgString(Plugin));
1334
1335 // Try to pass driver level flags relevant to LTO code generation down to
1336 // the plugin.
1337
1338 // Handle flags for selecting CPU variants.
1339 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1340 if (!CPU.empty())
1341 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1342}
1343
Jim Grosbach82eee262013-11-16 00:53:35 +00001344static void getX86TargetFeatures(const llvm::Triple &Triple,
1345 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001346 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001347 if (Triple.getArchName() == "x86_64h") {
1348 // x86_64h implies quite a few of the more modern subtarget features
1349 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1350 Features.push_back("-rdrnd");
1351 Features.push_back("-aes");
1352 Features.push_back("-pclmul");
1353 Features.push_back("-rtm");
1354 Features.push_back("-hle");
1355 Features.push_back("-fsgsbase");
1356 }
1357
Alexey Bataev286d1b92014-01-31 04:07:13 +00001358 if (Triple.getEnvironment() == llvm::Triple::Android) {
1359 // Add sse3 feature to comply with gcc on Android
1360 Features.push_back("+sse3");
1361 }
1362
Jim Grosbach82eee262013-11-16 00:53:35 +00001363 // Now add any that the user explicitly requested on the command line,
1364 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001365 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1366 ie = Args.filtered_end();
1367 it != ie; ++it) {
1368 StringRef Name = (*it)->getOption().getName();
1369 (*it)->claim();
1370
1371 // Skip over "-m".
1372 assert(Name.startswith("m") && "Invalid feature name.");
1373 Name = Name.substr(1);
1374
1375 bool IsNegative = Name.startswith("no-");
1376 if (IsNegative)
1377 Name = Name.substr(3);
1378
1379 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1380 }
1381}
1382
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001383void Clang::AddX86TargetArgs(const ArgList &Args,
1384 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001385 if (!Args.hasFlag(options::OPT_mred_zone,
1386 options::OPT_mno_red_zone,
1387 true) ||
1388 Args.hasArg(options::OPT_mkernel) ||
1389 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001390 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001391
Bob Wilson2616e2e2013-02-10 16:01:41 +00001392 // Default to avoid implicit floating-point for kernel/kext code, but allow
1393 // that to be overridden with -mno-soft-float.
1394 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1395 Args.hasArg(options::OPT_fapple_kext));
1396 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1397 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001398 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001399 options::OPT_mno_implicit_float)) {
1400 const Option &O = A->getOption();
1401 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1402 O.matches(options::OPT_msoft_float));
1403 }
1404 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001405 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001406}
1407
Matthew Curtise8f80a12012-12-06 17:49:03 +00001408static inline bool HasPICArg(const ArgList &Args) {
1409 return Args.hasArg(options::OPT_fPIC)
1410 || Args.hasArg(options::OPT_fpic);
1411}
1412
1413static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1414 return Args.getLastArg(options::OPT_G,
1415 options::OPT_G_EQ,
1416 options::OPT_msmall_data_threshold_EQ);
1417}
1418
1419static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1420 std::string value;
1421 if (HasPICArg(Args))
1422 value = "0";
1423 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1424 value = A->getValue();
1425 A->claim();
1426 }
1427 return value;
1428}
1429
Tony Linthicum76329bf2011-12-12 21:14:55 +00001430void Clang::AddHexagonTargetArgs(const ArgList &Args,
1431 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001432 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001433 CmdArgs.push_back("-mqdsp6-compat");
1434 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001435
Matthew Curtise8f80a12012-12-06 17:49:03 +00001436 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1437 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001438 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001439 CmdArgs.push_back(Args.MakeArgString(
1440 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001441 }
1442
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001443 if (!Args.hasArg(options::OPT_fno_short_enums))
1444 CmdArgs.push_back("-fshort-enums");
1445 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1446 CmdArgs.push_back ("-mllvm");
1447 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1448 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001449 CmdArgs.push_back ("-mllvm");
1450 CmdArgs.push_back ("-machine-sink-split=0");
1451}
1452
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001453static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1454 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001455 // Honor -mfpu=.
1456 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001457 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001458 else
1459 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001460
1461 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1462 Features.push_back("-fp-armv8");
1463 Features.push_back("-crypto");
1464 Features.push_back("-neon");
1465 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001466}
1467
1468static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001469 const ArgList &Args, ArgStringList &CmdArgs,
1470 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001471 std::vector<const char *> Features;
1472 switch (Triple.getArch()) {
1473 default:
1474 break;
1475 case llvm::Triple::mips:
1476 case llvm::Triple::mipsel:
1477 case llvm::Triple::mips64:
1478 case llvm::Triple::mips64el:
1479 getMIPSTargetFeatures(D, Args, Features);
1480 break;
1481
1482 case llvm::Triple::arm:
1483 case llvm::Triple::thumb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001484 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001485 break;
1486
1487 case llvm::Triple::ppc:
1488 case llvm::Triple::ppc64:
1489 case llvm::Triple::ppc64le:
1490 getPPCTargetFeatures(Args, Features);
1491 break;
1492 case llvm::Triple::sparc:
1493 getSparcTargetFeatures(Args, Features);
1494 break;
1495 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001496 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001497 getAArch64TargetFeatures(D, Args, Features);
1498 break;
1499 case llvm::Triple::x86:
1500 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001501 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001502 break;
1503 }
Rafael Espindola43964802013-08-21 17:34:32 +00001504
1505 // Find the last of each feature.
1506 llvm::StringMap<unsigned> LastOpt;
1507 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1508 const char *Name = Features[I];
1509 assert(Name[0] == '-' || Name[0] == '+');
1510 LastOpt[Name + 1] = I;
1511 }
1512
1513 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1514 // If this feature was overridden, ignore it.
1515 const char *Name = Features[I];
1516 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1517 assert(LastI != LastOpt.end());
1518 unsigned Last = LastI->second;
1519 if (Last != I)
1520 continue;
1521
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001522 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001523 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001524 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001525}
1526
Eric Christopher84fbdb42011-08-19 00:30:14 +00001527static bool
John McCall5fb5df92012-06-20 06:18:46 +00001528shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001529 const llvm::Triple &Triple) {
1530 // We use the zero-cost exception tables for Objective-C if the non-fragile
1531 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1532 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001533 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001534 return true;
1535
Bob Wilson83e723a2013-12-05 19:38:42 +00001536 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001537 return false;
1538
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001539 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001540 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001541 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001542}
1543
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001544namespace {
1545 struct ExceptionSettings {
1546 bool ExceptionsEnabled;
1547 bool ShouldUseExceptionTables;
1548 ExceptionSettings() : ExceptionsEnabled(false),
1549 ShouldUseExceptionTables(false) {}
1550 };
1551} // end anonymous namespace.
1552
Robert Lytton694f8842014-02-13 10:38:56 +00001553// exceptionSettings() exists to share the logic between -cc1 and linker invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001554static ExceptionSettings exceptionSettings(const ArgList &Args,
1555 const llvm::Triple &Triple) {
1556 ExceptionSettings ES;
1557
1558 // Are exceptions enabled by default?
1559 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1560
1561 // This keeps track of whether exceptions were explicitly turned on or off.
1562 bool DidHaveExplicitExceptionFlag = false;
1563
1564 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1565 options::OPT_fno_exceptions)) {
1566 if (A->getOption().matches(options::OPT_fexceptions))
1567 ES.ExceptionsEnabled = true;
1568 else
1569 ES.ExceptionsEnabled = false;
1570
1571 DidHaveExplicitExceptionFlag = true;
1572 }
1573
1574 // Exception tables and cleanups can be enabled with -fexceptions even if the
1575 // language itself doesn't support exceptions.
1576 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1577 ES.ShouldUseExceptionTables = true;
1578
1579 return ES;
1580}
1581
Anders Carlssone96ab552011-02-28 02:27:16 +00001582/// addExceptionArgs - Adds exception related arguments to the driver command
1583/// arguments. There's a master flag, -fexceptions and also language specific
1584/// flags to enable/disable C++ and Objective-C exceptions.
1585/// This makes it possible to for example disable C++ exceptions but enable
1586/// Objective-C exceptions.
1587static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1588 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001589 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001590 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001591 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001592 if (KernelOrKext) {
1593 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1594 // arguments now to avoid warnings about unused arguments.
1595 Args.ClaimAllArgs(options::OPT_fexceptions);
1596 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1597 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1598 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1599 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1600 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001601 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001602 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001603
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001604 // Gather the exception settings from the command line arguments.
1605 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001606
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001607 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1608 // is not necessarily sensible, but follows GCC.
1609 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001610 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001611 options::OPT_fno_objc_exceptions,
1612 true)) {
1613 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001614
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001615 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001616 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001617 }
1618
1619 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001620 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001621
Eric Christopher84fbdb42011-08-19 00:30:14 +00001622 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1623 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001624 options::OPT_fexceptions,
1625 options::OPT_fno_exceptions)) {
1626 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1627 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001628 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001629 CXXExceptionsEnabled = false;
1630 }
1631
1632 if (CXXExceptionsEnabled) {
1633 CmdArgs.push_back("-fcxx-exceptions");
1634
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001635 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001636 }
1637 }
1638
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001639 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001640 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001641}
1642
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001643static bool ShouldDisableAutolink(const ArgList &Args,
1644 const ToolChain &TC) {
1645 bool Default = true;
1646 if (TC.getTriple().isOSDarwin()) {
1647 // The native darwin assembler doesn't support the linker_option directives,
1648 // so we disable them if we think the .s file will be passed to it.
1649 Default = TC.useIntegratedAs();
1650 }
1651 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1652 Default);
1653}
1654
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001655static bool ShouldDisableCFI(const ArgList &Args,
1656 const ToolChain &TC) {
Rafael Espindolac41db922012-03-08 14:39:55 +00001657 bool Default = true;
Bob Wilson6524dd32011-10-14 05:03:44 +00001658 if (TC.getTriple().isOSDarwin()) {
Rafael Espindolaf934f982011-05-17 16:26:17 +00001659 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindola35ab91c2011-05-17 19:06:58 +00001660 // we disable them if we think the .s file will be passed to it.
Rafael Espindola84b588b2013-03-18 18:10:27 +00001661 Default = TC.useIntegratedAs();
Rafael Espindolaf934f982011-05-17 16:26:17 +00001662 }
Rafael Espindolac41db922012-03-08 14:39:55 +00001663 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
Eric Christopher45f2e712012-12-18 00:31:10 +00001664 options::OPT_fno_dwarf2_cfi_asm,
1665 Default);
Rafael Espindola4cfa7972011-05-02 17:43:32 +00001666}
1667
Ted Kremenek62093662013-03-12 17:02:12 +00001668static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1669 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001670 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1671 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001672 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001673 return !UseDwarfDirectory;
1674}
1675
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001676/// \brief Check whether the given input tree contains any compilation actions.
1677static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001678 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001679 return true;
1680
1681 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1682 if (ContainsCompileAction(*it))
1683 return true;
1684
1685 return false;
1686}
1687
1688/// \brief Check if -relax-all should be passed to the internal assembler.
1689/// This is done by default when compiling non-assembler source with -O0.
1690static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1691 bool RelaxDefault = true;
1692
1693 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1694 RelaxDefault = A->getOption().matches(options::OPT_O0);
1695
1696 if (RelaxDefault) {
1697 RelaxDefault = false;
1698 for (ActionList::const_iterator it = C.getActions().begin(),
1699 ie = C.getActions().end(); it != ie; ++it) {
1700 if (ContainsCompileAction(*it)) {
1701 RelaxDefault = true;
1702 break;
1703 }
1704 }
1705 }
1706
1707 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1708 RelaxDefault);
1709}
1710
David Blaikie9260ed62013-07-25 21:19:01 +00001711static void CollectArgsForIntegratedAssembler(Compilation &C,
1712 const ArgList &Args,
1713 ArgStringList &CmdArgs,
1714 const Driver &D) {
1715 if (UseRelaxAll(C, Args))
1716 CmdArgs.push_back("-mrelax-all");
1717
David Peixottodfb66142013-11-14 22:52:58 +00001718 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001719 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001720 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1721 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1722 // arg after parsing the '-I' arg.
1723 bool TakeNextArg = false;
1724
David Blaikie9260ed62013-07-25 21:19:01 +00001725 // When using an integrated assembler, translate -Wa, and -Xassembler
1726 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001727 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001728 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1729 options::OPT_Xassembler),
1730 ie = Args.filtered_end(); it != ie; ++it) {
1731 const Arg *A = *it;
1732 A->claim();
1733
1734 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1735 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001736 if (TakeNextArg) {
1737 CmdArgs.push_back(Value.data());
1738 TakeNextArg = false;
1739 continue;
1740 }
David Blaikie9260ed62013-07-25 21:19:01 +00001741
1742 if (Value == "-force_cpusubtype_ALL") {
1743 // Do nothing, this is the default and we don't support anything else.
1744 } else if (Value == "-L") {
1745 CmdArgs.push_back("-msave-temp-labels");
1746 } else if (Value == "--fatal-warnings") {
1747 CmdArgs.push_back("-mllvm");
1748 CmdArgs.push_back("-fatal-assembler-warnings");
1749 } else if (Value == "--noexecstack") {
1750 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001751 } else if (Value == "-compress-debug-sections" ||
1752 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001753 CompressDebugSections = true;
1754 } else if (Value == "-nocompress-debug-sections" ||
1755 Value == "--nocompress-debug-sections") {
1756 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001757 } else if (Value.startswith("-I")) {
1758 CmdArgs.push_back(Value.data());
1759 // We need to consume the next argument if the current arg is a plain
1760 // -I. The next arg will be the include directory.
1761 if (Value == "-I")
1762 TakeNextArg = true;
David Blaikie9260ed62013-07-25 21:19:01 +00001763 } else {
1764 D.Diag(diag::err_drv_unsupported_option_argument)
1765 << A->getOption().getName() << Value;
1766 }
1767 }
1768 }
David Blaikie7e2fd942014-03-27 20:47:30 +00001769 if (CompressDebugSections)
1770 CmdArgs.push_back("-compress-debug-sections");
David Blaikie9260ed62013-07-25 21:19:01 +00001771}
1772
Renato Goline807c122014-01-31 11:47:28 +00001773// Until ARM libraries are build separately, we have them all in one library
1774static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
1775 if (TC.getArch() == llvm::Triple::arm)
1776 return "arm";
1777 else
1778 return TC.getArchName();
1779}
1780
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001781static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1782 // The runtimes are located in the OS-specific resource directory.
1783 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001784 const llvm::Triple &Triple = TC.getTriple();
1785 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1786 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1787 "freebsd" : TC.getOS();
1788 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001789 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001790}
1791
Renato Golinc4b49242014-02-13 10:01:16 +00001792// This adds the static libclang_rt.arch.a directly to the command line
1793// FIXME: Make sure we can also emit shared objects if they're requested
1794// and available, check for possible errors, etc.
1795static void addClangRTLinux(
1796 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001797 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
1798 llvm::sys::path::append(LibClangRT,
Renato Golinc4b49242014-02-13 10:01:16 +00001799 Twine("libclang_rt.") + getArchNameForCompilerRTLib(TC) + ".a");
1800
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001801 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001802 CmdArgs.push_back("-lgcc_s");
1803 if (TC.getDriver().CCCIsCXX())
1804 CmdArgs.push_back("-lgcc_eh");
1805}
1806
Alexey Samsonov7811d192014-02-20 13:57:37 +00001807static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001808 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1809 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1810 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001811 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001812 Args.hasArg(options::OPT_fcreate_profile) ||
1813 Args.hasArg(options::OPT_coverage)))
1814 return;
1815
Duncan P. N. Exon Smitha19ffae2014-03-27 16:20:02 +00001816 // Pull in runtime for -fprofile-inst-generate. This is required since there
1817 // are no calls to the runtime in the code.
1818 if (Args.hasArg(options::OPT_fprofile_instr_generate)) {
1819 CmdArgs.push_back("-u");
1820 CmdArgs.push_back("___llvm_profile_runtime");
1821 }
1822
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001823 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1824 llvm::sys::path::append(LibProfile,
Renato Goline807c122014-01-31 11:47:28 +00001825 Twine("libclang_rt.profile-") + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001826
1827 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1828}
1829
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001830static void addSanitizerRTLinkFlags(
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001831 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
Richard Smithf3e624c2013-03-23 00:30:08 +00001832 const StringRef Sanitizer, bool BeforeLibStdCXX,
1833 bool ExportSymbols = true) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001834 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1835 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1836 llvm::sys::path::append(LibSanitizer,
1837 (Twine("libclang_rt.") + Sanitizer + "-" +
1838 getArchNameForCompilerRTLib(TC) + ".a"));
Richard Smithcff3cde2013-03-20 23:49:07 +00001839
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001840 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1841 // etc.) so that the linker picks custom versions of the global 'operator
1842 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001843 // strategy of inserting it at the front of the link command. It also
1844 // needs to be forced to end up in the executable, so wrap it in
1845 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001846 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001847 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001848 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001849 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001850
1851 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1852 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1853
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001854 CmdArgs.push_back("-lpthread");
Evgeniy Stepanov758b5072013-05-24 14:28:03 +00001855 CmdArgs.push_back("-lrt");
Evgeniy Stepanov4ae68462013-10-29 19:48:47 +00001856 CmdArgs.push_back("-lm");
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001857 // There's no libdl on FreeBSD.
1858 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1859 CmdArgs.push_back("-ldl");
Richard Smithf3e624c2013-03-23 00:30:08 +00001860
1861 // If possible, use a dynamic symbols file to export the symbols from the
1862 // runtime library. If we can't do so, use -export-dynamic instead to export
1863 // all symbols from the binary.
1864 if (ExportSymbols) {
1865 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1866 CmdArgs.push_back(
1867 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1868 else
1869 CmdArgs.push_back("-export-dynamic");
1870 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001871}
1872
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001873/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1874/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001875static void addAsanRT(const ToolChain &TC, const ArgList &Args,
1876 ArgStringList &CmdArgs) {
Nick Lewycky609dd662013-10-11 03:33:53 +00001877 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001878 SmallString<128> LibAsan = getCompilerRTLibDir(TC);
1879 llvm::sys::path::append(LibAsan,
1880 (Twine("libclang_rt.asan-") +
1881 getArchNameForCompilerRTLib(TC) + "-android.so"));
Matt Beaumont-Gay35439df2012-12-04 21:18:26 +00001882 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001883 } else {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001884 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001885 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001886 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001887}
1888
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001889/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1890/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001891static void addTsanRT(const ToolChain &TC, const ArgList &Args,
1892 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001893 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001894 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00001895}
1896
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001897/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1898/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001899static void addMsanRT(const ToolChain &TC, const ArgList &Args,
1900 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001901 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001902 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001903}
1904
1905/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1906/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001907static void addLsanRT(const ToolChain &TC, const ArgList &Args,
1908 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00001909 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001910 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00001911}
1912
Richard Smithe30752c2012-10-09 19:52:38 +00001913/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1914/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001915static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
1916 ArgStringList &CmdArgs, bool IsCXX,
1917 bool HasOtherSanitizerRt) {
Nick Lewycky24921692013-10-19 00:27:23 +00001918 // Need a copy of sanitizer_common. This could come from another sanitizer
1919 // runtime; if we're not including one, include our own copy.
1920 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001921 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001922
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001923 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001924
1925 // Only include the bits of the runtime which need a C++ ABI library if
1926 // we're linking in C++ mode.
1927 if (IsCXX)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001928 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false);
Richard Smithe30752c2012-10-09 19:52:38 +00001929}
1930
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001931static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
1932 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00001933 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001934 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
1935}
1936
1937// Should be called before we add C++ ABI library.
1938static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
1939 ArgStringList &CmdArgs) {
1940 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
1941 const Driver &D = TC.getDriver();
1942 if (Sanitize.needsUbsanRt())
1943 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
1944 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
1945 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
1946 if (Sanitize.needsAsanRt())
1947 addAsanRT(TC, Args, CmdArgs);
1948 if (Sanitize.needsTsanRt())
1949 addTsanRT(TC, Args, CmdArgs);
1950 if (Sanitize.needsMsanRt())
1951 addMsanRT(TC, Args, CmdArgs);
1952 if (Sanitize.needsLsanRt())
1953 addLsanRT(TC, Args, CmdArgs);
1954 if (Sanitize.needsDfsanRt())
1955 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00001956}
1957
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001958static bool shouldUseFramePointerForTarget(const ArgList &Args,
1959 const llvm::Triple &Triple) {
1960 switch (Triple.getArch()) {
1961 // Don't use a frame pointer on linux if optimizing for certain targets.
1962 case llvm::Triple::mips64:
1963 case llvm::Triple::mips64el:
1964 case llvm::Triple::mips:
1965 case llvm::Triple::mipsel:
1966 case llvm::Triple::systemz:
1967 case llvm::Triple::x86:
1968 case llvm::Triple::x86_64:
1969 if (Triple.isOSLinux())
1970 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1971 if (!A->getOption().matches(options::OPT_O0))
1972 return false;
1973 return true;
1974 case llvm::Triple::xcore:
1975 return false;
1976 default:
1977 return true;
1978 }
1979}
1980
Rafael Espindola224dd632011-12-14 21:02:23 +00001981static bool shouldUseFramePointer(const ArgList &Args,
1982 const llvm::Triple &Triple) {
1983 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1984 options::OPT_fomit_frame_pointer))
1985 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1986
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001987 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00001988}
1989
Eric Christopherb7d97e92013-04-03 01:58:53 +00001990static bool shouldUseLeafFramePointer(const ArgList &Args,
1991 const llvm::Triple &Triple) {
1992 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1993 options::OPT_momit_leaf_frame_pointer))
1994 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1995
Benjamin Kramer34cb0432013-10-16 17:42:39 +00001996 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00001997}
1998
Rafael Espindolac7367ff2013-08-10 01:40:10 +00001999/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002000static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002001 SmallString<128> cwd;
2002 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002003 CmdArgs.push_back("-fdebug-compilation-dir");
2004 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002005 }
2006}
2007
Eric Christopherd3804002013-02-22 20:12:52 +00002008static const char *SplitDebugName(const ArgList &Args,
2009 const InputInfoList &Inputs) {
2010 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2011 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2012 SmallString<128> T(FinalOutput->getValue());
2013 llvm::sys::path::replace_extension(T, "dwo");
2014 return Args.MakeArgString(T);
2015 } else {
2016 // Use the compilation dir.
2017 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2018 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2019 llvm::sys::path::replace_extension(F, "dwo");
2020 T += F;
2021 return Args.MakeArgString(F);
2022 }
2023}
2024
2025static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2026 const Tool &T, const JobAction &JA,
2027 const ArgList &Args, const InputInfo &Output,
2028 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002029 ArgStringList ExtractArgs;
2030 ExtractArgs.push_back("--extract-dwo");
2031
2032 ArgStringList StripArgs;
2033 StripArgs.push_back("--strip-dwo");
2034
2035 // Grabbing the output of the earlier compile step.
2036 StripArgs.push_back(Output.getFilename());
2037 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002038 ExtractArgs.push_back(OutFile);
2039
2040 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002041 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002042
2043 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002044 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002045
2046 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002047 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002048}
2049
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002050/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2051static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2052 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002053 if (A->getOption().matches(options::OPT_O4) ||
2054 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002055 return true;
2056
2057 if (A->getOption().matches(options::OPT_O0))
2058 return false;
2059
2060 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2061
Rafael Espindola91780de2013-08-26 14:05:41 +00002062 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002063 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002064 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002065 return true;
2066
2067 // Don't vectorize -Oz.
2068 if (S == "z")
2069 return false;
2070
2071 unsigned OptLevel = 0;
2072 if (S.getAsInteger(10, OptLevel))
2073 return false;
2074
2075 return OptLevel > 1;
2076 }
2077
2078 return false;
2079}
2080
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002081/// Add -x lang to \p CmdArgs for \p Input.
2082static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2083 ArgStringList &CmdArgs) {
2084 // When using -verify-pch, we don't want to provide the type
2085 // 'precompiled-header' if it was inferred from the file extension
2086 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2087 return;
2088
2089 CmdArgs.push_back("-x");
2090 if (Args.hasArg(options::OPT_rewrite_objc))
2091 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2092 else
2093 CmdArgs.push_back(types::getTypeName(Input.getType()));
2094}
2095
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002096void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002097 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002098 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002099 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002100 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002101 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2102 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002103 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002104 ArgStringList CmdArgs;
2105
Daniel Dunbare521a892009-03-31 20:53:55 +00002106 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2107
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002108 // Invoke ourselves in -cc1 mode.
2109 //
2110 // FIXME: Implement custom jobs for internal actions.
2111 CmdArgs.push_back("-cc1");
2112
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002113 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002114 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002115 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002116 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002117
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002118 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002119 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002120
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002121 if (isa<AnalyzeJobAction>(JA)) {
2122 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2123 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002124 } else if (isa<MigrateJobAction>(JA)) {
2125 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002126 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002127 if (Output.getType() == types::TY_Dependencies)
2128 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002129 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002130 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002131 if (Args.hasArg(options::OPT_rewrite_objc) &&
2132 !Args.hasArg(options::OPT_g_Group))
2133 CmdArgs.push_back("-P");
2134 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002135 } else if (isa<AssembleJobAction>(JA)) {
2136 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002137
David Blaikie9260ed62013-07-25 21:19:01 +00002138 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002139
2140 // Also ignore explicit -force_cpusubtype_ALL option.
2141 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002142 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002143 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002144 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002145
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002146 if (JA.getType() == types::TY_Nothing)
2147 CmdArgs.push_back("-fsyntax-only");
2148 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002149 CmdArgs.push_back("-emit-pch");
2150 else
2151 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002152 } else if (isa<VerifyPCHJobAction>(JA)) {
2153 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002154 } else {
2155 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002156
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002157 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002158 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002159 } else if (JA.getType() == types::TY_LLVM_IR ||
2160 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002161 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002162 } else if (JA.getType() == types::TY_LLVM_BC ||
2163 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002164 CmdArgs.push_back("-emit-llvm-bc");
2165 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002166 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002167 } else if (JA.getType() == types::TY_AST) {
2168 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002169 } else if (JA.getType() == types::TY_ModuleFile) {
2170 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002171 } else if (JA.getType() == types::TY_RewrittenObjC) {
2172 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002173 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002174 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2175 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002176 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002177 } else {
2178 assert(JA.getType() == types::TY_PP_Asm &&
2179 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002180 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002181 }
2182
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002183 // The make clang go fast button.
2184 CmdArgs.push_back("-disable-free");
2185
John McCallbb79b5f2010-02-13 03:50:24 +00002186 // Disable the verification pass in -asserts builds.
2187#ifdef NDEBUG
2188 CmdArgs.push_back("-disable-llvm-verifier");
2189#endif
2190
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002191 // Set the main file name, so that debug info works even with
2192 // -save-temps.
2193 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002194 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002195
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002196 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002197 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002198 if (Args.hasArg(options::OPT_static))
2199 CmdArgs.push_back("-static-define");
2200
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002201 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002202 // Enable region store model by default.
2203 CmdArgs.push_back("-analyzer-store=region");
2204
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002205 // Treat blocks as analysis entry points.
2206 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2207
Ted Kremenek49c79792011-03-24 00:28:47 +00002208 CmdArgs.push_back("-analyzer-eagerly-assume");
2209
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002210 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002211 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002212 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002213
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002214 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2215 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002216
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002217 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002218 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002219
2220 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002221
Jordan Rose10ad0812013-04-05 17:55:07 +00002222 if (types::isCXX(Inputs[0].getType()))
2223 CmdArgs.push_back("-analyzer-checker=cplusplus");
2224
Ted Kremenek37e96522012-01-26 02:27:38 +00002225 // Enable the following experimental checkers for testing.
Ted Kremenek37e96522012-01-26 02:27:38 +00002226 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2227 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2228 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2229 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2230 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2231 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002232 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002233
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002234 // Set the output format. The default is plist, for (lame) historical
2235 // reasons.
2236 CmdArgs.push_back("-analyzer-output");
2237 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002238 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002239 else
2240 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002241
Ted Kremenekfe449a22010-03-22 22:32:05 +00002242 // Disable the presentation of standard compiler warnings when
2243 // using --analyze. We only want to show static analyzer diagnostics
2244 // or frontend errors.
2245 CmdArgs.push_back("-w");
2246
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002247 // Add -Xanalyzer arguments when running as analyzer.
2248 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002249 }
2250
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002251 CheckCodeGenerationOptions(D, Args);
2252
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002253 bool PIE = getToolChain().isPIEDefault();
2254 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002255 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002256
Alexey Bataev40e75222014-01-28 06:30:35 +00002257 // Android-specific defaults for PIC/PIE
2258 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2259 switch (getToolChain().getTriple().getArch()) {
2260 case llvm::Triple::arm:
2261 case llvm::Triple::thumb:
2262 case llvm::Triple::mips:
2263 case llvm::Triple::mipsel:
2264 case llvm::Triple::mips64:
2265 case llvm::Triple::mips64el:
2266 PIC = true; // "-fpic"
2267 break;
2268
2269 case llvm::Triple::x86:
2270 case llvm::Triple::x86_64:
2271 PIC = true; // "-fPIC"
2272 IsPICLevelTwo = true;
2273 break;
2274
2275 default:
2276 break;
2277 }
2278 }
2279
Alexey Samsonov090301e2013-04-09 12:28:19 +00002280 // For the PIC and PIE flag options, this logic is different from the
2281 // legacy logic in very old versions of GCC, as that logic was just
2282 // a bug no one had ever fixed. This logic is both more rational and
2283 // consistent with GCC's new logic now that the bugs are fixed. The last
2284 // argument relating to either PIC or PIE wins, and no other argument is
2285 // used. If the last argument is any flavor of the '-fno-...' arguments,
2286 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2287 // at the same level.
2288 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2289 options::OPT_fpic, options::OPT_fno_pic,
2290 options::OPT_fPIE, options::OPT_fno_PIE,
2291 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002292 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2293 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002294 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002295 if (LastPICArg) {
2296 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002297 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2298 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2299 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2300 PIC = PIE || O.matches(options::OPT_fPIC) ||
2301 O.matches(options::OPT_fpic);
2302 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2303 O.matches(options::OPT_fPIC);
2304 } else {
2305 PIE = PIC = false;
2306 }
2307 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002308 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002309
Nick Lewycky609dd662013-10-11 03:33:53 +00002310 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002311 // specified while enabling PIC enabled level 1 PIC, just force it back to
2312 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2313 // informal testing).
2314 if (PIC && getToolChain().getTriple().isOSDarwin())
2315 IsPICLevelTwo |= getToolChain().isPICDefault();
2316
Chandler Carruthc0c04552012-04-08 16:40:35 +00002317 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2318 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002319 llvm::Triple Triple(TripleStr);
Eric Christopher8d56caa2013-02-18 01:16:37 +00002320 if (KernelOrKext &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002321 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002322 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002323 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002324 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002325
Chandler Carruth76a943b2012-11-19 03:52:03 +00002326 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2327 // This is a very special mode. It trumps the other modes, almost no one
2328 // uses it, and it isn't even valid on any OS but Darwin.
2329 if (!getToolChain().getTriple().isOSDarwin())
2330 D.Diag(diag::err_drv_unsupported_opt_for_target)
2331 << A->getSpelling() << getToolChain().getTriple().str();
2332
2333 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2334
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002335 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002336 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002337
Chandler Carruth76a943b2012-11-19 03:52:03 +00002338 // Only a forced PIC mode can cause the actual compile to have PIC defines
2339 // etc., no flags are sufficient. This behavior was selected to closely
2340 // match that of llvm-gcc and Apple GCC before that.
2341 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2342 CmdArgs.push_back("-pic-level");
2343 CmdArgs.push_back("2");
2344 }
2345 } else {
2346 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2347 // handled in Clang's IRGen by the -pie-level flag.
2348 CmdArgs.push_back("-mrelocation-model");
2349 CmdArgs.push_back(PIC ? "pic" : "static");
2350
2351 if (PIC) {
2352 CmdArgs.push_back("-pic-level");
2353 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2354 if (PIE) {
2355 CmdArgs.push_back("-pie-level");
2356 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2357 }
2358 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002359 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002360
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002361 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2362 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002363 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002364
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002365 // LLVM Code Generator Options.
2366
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002367 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2368 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002369 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002370 }
2371
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002372 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2373 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002374 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002375 D.Diag(diag::err_drv_unsupported_opt_for_target)
2376 << A->getSpelling() << getToolChain().getTriple().str();
2377 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2378 CmdArgs.push_back("-fpcc-struct-return");
2379 } else {
2380 assert(A->getOption().matches(options::OPT_freg_struct_return));
2381 CmdArgs.push_back("-freg-struct-return");
2382 }
2383 }
2384
Roman Divacky65b88cd2011-03-01 17:40:53 +00002385 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2386 CmdArgs.push_back("-mrtd");
2387
Rafael Espindola224dd632011-12-14 21:02:23 +00002388 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002389 CmdArgs.push_back("-mdisable-fp-elim");
2390 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2391 options::OPT_fno_zero_initialized_in_bss))
2392 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002393
2394 bool OFastEnabled = isOptimizationLevelFast(Args);
2395 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2396 // enabled. This alias option is being used to simplify the hasFlag logic.
2397 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2398 options::OPT_fstrict_aliasing;
2399 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Rafael Espindola8f41aee2013-11-17 22:42:24 +00002400 options::OPT_fno_strict_aliasing, true))
Dan Gohman10169b92010-10-14 22:36:56 +00002401 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002402 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2403 options::OPT_fno_struct_path_tbaa))
2404 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002405 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2406 false))
2407 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002408 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2409 options::OPT_fno_optimize_sibling_calls))
2410 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002411
Eric Christopher006208c2013-04-04 06:29:47 +00002412 // Handle segmented stacks.
2413 if (Args.hasArg(options::OPT_fsplit_stack))
2414 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002415
2416 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2417 // This alias option is being used to simplify the getLastArg logic.
2418 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2419 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002420
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002421 // Handle various floating point optimization flags, mapping them to the
2422 // appropriate LLVM code generation flags. The pattern for all of these is to
2423 // default off the codegen optimizations, and if any flag enables them and no
2424 // flag disables them after the flag enabling them, enable the codegen
2425 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002426 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002427 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002428 options::OPT_ffinite_math_only,
2429 options::OPT_fno_finite_math_only,
2430 options::OPT_fhonor_infinities,
2431 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002432 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2433 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002434 A->getOption().getID() != options::OPT_fhonor_infinities)
2435 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002436 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002437 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002438 options::OPT_ffinite_math_only,
2439 options::OPT_fno_finite_math_only,
2440 options::OPT_fhonor_nans,
2441 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002442 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2443 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002444 A->getOption().getID() != options::OPT_fhonor_nans)
2445 CmdArgs.push_back("-menable-no-nans");
2446
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002447 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2448 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002449 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002450 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002451 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002452 options::OPT_fno_math_errno)) {
2453 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2454 // However, turning *off* -ffast_math merely restores the toolchain default
2455 // (which may be false).
2456 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2457 A->getOption().getID() == options::OPT_ffast_math ||
2458 A->getOption().getID() == options::OPT_Ofast)
2459 MathErrno = false;
2460 else if (A->getOption().getID() == options::OPT_fmath_errno)
2461 MathErrno = true;
2462 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002463 if (MathErrno)
2464 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002465
2466 // There are several flags which require disabling very specific
2467 // optimizations. Any of these being disabled forces us to turn off the
2468 // entire set of LLVM optimizations, so collect them through all the flag
2469 // madness.
2470 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002471 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002472 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002473 options::OPT_funsafe_math_optimizations,
2474 options::OPT_fno_unsafe_math_optimizations,
2475 options::OPT_fassociative_math,
2476 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002477 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2478 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002479 A->getOption().getID() != options::OPT_fno_associative_math)
2480 AssociativeMath = true;
2481 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002482 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002483 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002484 options::OPT_funsafe_math_optimizations,
2485 options::OPT_fno_unsafe_math_optimizations,
2486 options::OPT_freciprocal_math,
2487 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002488 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2489 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002490 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2491 ReciprocalMath = true;
2492 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002493 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002494 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002495 options::OPT_funsafe_math_optimizations,
2496 options::OPT_fno_unsafe_math_optimizations,
2497 options::OPT_fsigned_zeros,
2498 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002499 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2500 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002501 A->getOption().getID() != options::OPT_fsigned_zeros)
2502 SignedZeros = false;
2503 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002504 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002505 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002506 options::OPT_funsafe_math_optimizations,
2507 options::OPT_fno_unsafe_math_optimizations,
2508 options::OPT_ftrapping_math,
2509 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002510 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2511 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002512 A->getOption().getID() != options::OPT_ftrapping_math)
2513 TrappingMath = false;
2514 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2515 !TrappingMath)
2516 CmdArgs.push_back("-menable-unsafe-fp-math");
2517
Lang Hamesaa53b932012-07-06 00:59:19 +00002518
2519 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002520 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002521 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002522 options::OPT_ffp_contract)) {
2523 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002524 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002525 if (Val == "fast" || Val == "on" || Val == "off") {
2526 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2527 } else {
2528 D.Diag(diag::err_drv_unsupported_option_argument)
2529 << A->getOption().getName() << Val;
2530 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002531 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2532 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002533 // If fast-math is set then set the fp-contract mode to fast.
2534 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2535 }
2536 }
2537
Bob Wilson6a039162012-07-19 03:52:53 +00002538 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2539 // and if we find them, tell the frontend to provide the appropriate
2540 // preprocessor macros. This is distinct from enabling any optimizations as
2541 // these options induce language changes which must survive serialization
2542 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002543 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2544 options::OPT_fno_fast_math))
2545 if (!A->getOption().matches(options::OPT_fno_fast_math))
2546 CmdArgs.push_back("-ffast-math");
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002547 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2548 if (A->getOption().matches(options::OPT_ffinite_math_only))
2549 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002550
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002551 // Decide whether to use verbose asm. Verbose assembly is the default on
2552 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002553 bool IsIntegratedAssemblerDefault =
2554 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002555 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002556 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002557 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002558 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002559
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002560 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002561 IsIntegratedAssemblerDefault))
2562 CmdArgs.push_back("-no-integrated-as");
2563
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002564 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2565 CmdArgs.push_back("-mdebug-pass");
2566 CmdArgs.push_back("Structure");
2567 }
2568 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2569 CmdArgs.push_back("-mdebug-pass");
2570 CmdArgs.push_back("Arguments");
2571 }
2572
John McCall8517abc2010-02-19 02:45:38 +00002573 // Enable -mconstructor-aliases except on darwin, where we have to
2574 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002575 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002576 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002577
John McCall7ef5cb32011-03-18 02:56:14 +00002578 // Darwin's kernel doesn't support guard variables; just die if we
2579 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002580 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002581 CmdArgs.push_back("-fforbid-guard-variables");
2582
Douglas Gregordbe39272011-02-01 15:15:22 +00002583 if (Args.hasArg(options::OPT_mms_bitfields)) {
2584 CmdArgs.push_back("-mms-bitfields");
2585 }
John McCall8517abc2010-02-19 02:45:38 +00002586
Daniel Dunbar306945d2009-09-16 06:17:29 +00002587 // This is a coarse approximation of what llvm-gcc actually does, both
2588 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2589 // complicated ways.
2590 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002591 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2592 options::OPT_fno_asynchronous_unwind_tables,
2593 (getToolChain().IsUnwindTablesDefault() ||
2594 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2595 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002596 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2597 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002598 CmdArgs.push_back("-munwind-tables");
2599
Chandler Carruth05fb5852012-11-21 23:40:23 +00002600 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002601
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002602 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2603 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002604 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002605 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002606
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002607 // FIXME: Handle -mtune=.
2608 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002609
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002610 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002611 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002612 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002613 }
2614
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002615 // Add the target cpu
2616 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2617 llvm::Triple ETriple(ETripleStr);
2618 std::string CPU = getCPUName(Args, ETriple);
2619 if (!CPU.empty()) {
2620 CmdArgs.push_back("-target-cpu");
2621 CmdArgs.push_back(Args.MakeArgString(CPU));
2622 }
2623
Rafael Espindolaeb265472013-08-21 21:59:03 +00002624 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2625 CmdArgs.push_back("-mfpmath");
2626 CmdArgs.push_back(A->getValue());
2627 }
2628
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002629 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002630 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002631
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002632 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002633 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002634 default:
2635 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002636
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002637 case llvm::Triple::arm:
2638 case llvm::Triple::thumb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002639 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002640 break;
2641
Eric Christopher0b26a612010-03-02 02:41:08 +00002642 case llvm::Triple::mips:
2643 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002644 case llvm::Triple::mips64:
2645 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002646 AddMIPSTargetArgs(Args, CmdArgs);
2647 break;
2648
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002649 case llvm::Triple::sparc:
2650 AddSparcTargetArgs(Args, CmdArgs);
2651 break;
2652
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002653 case llvm::Triple::x86:
2654 case llvm::Triple::x86_64:
2655 AddX86TargetArgs(Args, CmdArgs);
2656 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002657
2658 case llvm::Triple::hexagon:
2659 AddHexagonTargetArgs(Args, CmdArgs);
2660 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002661 }
2662
Hans Wennborg75958c42013-08-08 00:17:41 +00002663 // Add clang-cl arguments.
2664 if (getToolChain().getDriver().IsCLMode())
2665 AddClangCLArgs(Args, CmdArgs);
2666
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002667 // Pass the linker version in use.
2668 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2669 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002670 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002671 }
2672
Eric Christopherb7d97e92013-04-03 01:58:53 +00002673 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002674 CmdArgs.push_back("-momit-leaf-frame-pointer");
2675
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002676 // Explicitly error on some things we know we don't support and can't just
2677 // ignore.
2678 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002679 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2680 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002681 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002682 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002683 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002684 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2685 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002686 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002687 << Unsupported->getOption().getName();
2688 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002689 }
2690
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002691 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002692 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002693 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002694 CmdArgs.push_back("-header-include-file");
2695 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2696 D.CCPrintHeadersFilename : "-");
2697 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002698 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002699 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002700
Chad Rosierbe10f982011-08-02 17:58:04 +00002701 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002702 CmdArgs.push_back("-diagnostic-log-file");
2703 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2704 D.CCLogDiagnosticsFilename : "-");
2705 }
2706
Manman Ren17bdb0f2013-11-20 20:22:14 +00002707 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2708 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002709 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002710 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002711 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002712 // FIXME: we should support specifying dwarf version with
2713 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002714 CmdArgs.push_back("-gline-tables-only");
Adrian Prantl549c5142014-02-17 17:40:52 +00002715 // Default is dwarf-2 for darwin.
2716 if (getToolChain().getTriple().isOSDarwin())
2717 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002718 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002719 CmdArgs.push_back("-gdwarf-2");
2720 else if (A->getOption().matches(options::OPT_gdwarf_3))
2721 CmdArgs.push_back("-gdwarf-3");
2722 else if (A->getOption().matches(options::OPT_gdwarf_4))
2723 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002724 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002725 !A->getOption().matches(options::OPT_ggdb0)) {
2726 // Default is dwarf-2 for darwin.
2727 if (getToolChain().getTriple().isOSDarwin())
2728 CmdArgs.push_back("-gdwarf-2");
2729 else
2730 CmdArgs.push_back("-g");
2731 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002732 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002733
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002734 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2735 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002736 if (Args.hasArg(options::OPT_gcolumn_info))
2737 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002738
Eric Christopher138c32b2013-09-13 22:37:55 +00002739 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002740 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2741 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002742 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002743 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002744 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002745 CmdArgs.push_back("-g");
2746 CmdArgs.push_back("-backend-option");
2747 CmdArgs.push_back("-split-dwarf=Enable");
2748 }
2749
Eric Christopher138c32b2013-09-13 22:37:55 +00002750 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2751 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2752 CmdArgs.push_back("-backend-option");
2753 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2754 }
Eric Christophereec89c22013-06-18 00:03:50 +00002755
Eric Christopher0d403d22014-02-14 01:27:03 +00002756 // -gdwarf-aranges turns on the emission of the aranges section in the
2757 // backend.
2758 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2759 CmdArgs.push_back("-backend-option");
2760 CmdArgs.push_back("-generate-arange-section");
2761 }
2762
David Blaikief36d9ba2014-01-27 18:52:43 +00002763 if (Args.hasFlag(options::OPT_fdebug_types_section,
2764 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002765 CmdArgs.push_back("-backend-option");
2766 CmdArgs.push_back("-generate-type-units");
2767 }
Eric Christophereec89c22013-06-18 00:03:50 +00002768
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002769 if (Args.hasFlag(options::OPT_ffunction_sections,
2770 options::OPT_fno_function_sections, false)) {
2771 CmdArgs.push_back("-ffunction-sections");
2772 }
2773
2774 if (Args.hasFlag(options::OPT_fdata_sections,
2775 options::OPT_fno_data_sections, false)) {
2776 CmdArgs.push_back("-fdata-sections");
2777 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002778
Chris Lattner3c77a352010-06-22 00:03:40 +00002779 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2780
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002781 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2782 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2783 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2784 D.Diag(diag::err_drv_argument_not_allowed_with)
2785 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2786
2787 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2788
2789 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2790 A->render(Args, CmdArgs);
2791 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2792 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
2793
Nick Lewycky207bce32011-04-21 23:44:07 +00002794 if (Args.hasArg(options::OPT_ftest_coverage) ||
2795 Args.hasArg(options::OPT_coverage))
2796 CmdArgs.push_back("-femit-coverage-notes");
2797 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2798 Args.hasArg(options::OPT_coverage))
2799 CmdArgs.push_back("-femit-coverage-data");
2800
Nick Lewycky480cb992011-05-04 20:46:58 +00002801 if (C.getArgs().hasArg(options::OPT_c) ||
2802 C.getArgs().hasArg(options::OPT_S)) {
2803 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002804 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00002805 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00002806 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002807 SmallString<128> Pwd;
2808 if (!llvm::sys::fs::current_path(Pwd)) {
2809 llvm::sys::path::append(Pwd, CoverageFilename.str());
2810 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00002811 }
2812 }
Eric Christophere30f61c2013-02-22 00:24:40 +00002813 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002814 }
2815 }
2816
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002817 // Pass options for controlling the default header search paths.
2818 if (Args.hasArg(options::OPT_nostdinc)) {
2819 CmdArgs.push_back("-nostdsysteminc");
2820 CmdArgs.push_back("-nobuiltininc");
2821 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002822 if (Args.hasArg(options::OPT_nostdlibinc))
2823 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002824 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2825 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2826 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002827
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002828 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002829 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002830 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002831
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002832 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2833
Ted Kremenekf7639e12012-03-06 20:06:33 +00002834 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00002835 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002836 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002837 options::OPT_ccc_arcmt_modify,
2838 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002839 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00002840 switch (A->getOption().getID()) {
2841 default:
2842 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002843 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00002844 CmdArgs.push_back("-arcmt-check");
2845 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00002846 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00002847 CmdArgs.push_back("-arcmt-modify");
2848 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002849 case options::OPT_ccc_arcmt_migrate:
2850 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002851 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002852 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00002853
2854 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2855 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00002856 break;
John McCalld70fb982011-06-15 23:25:17 +00002857 }
2858 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00002859 } else {
2860 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2861 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2862 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00002863 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00002864
Ted Kremenekf7639e12012-03-06 20:06:33 +00002865 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2866 if (ARCMTEnabled) {
2867 D.Diag(diag::err_drv_argument_not_allowed_with)
2868 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2869 }
2870 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00002871 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00002872
2873 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002874 options::OPT_objcmt_migrate_subscripting,
2875 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00002876 // None specified, means enable them all.
2877 CmdArgs.push_back("-objcmt-migrate-literals");
2878 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002879 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002880 } else {
2881 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2882 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00002883 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002884 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00002885 } else {
2886 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2887 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2888 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2889 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2890 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2891 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2892 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2893 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2894 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2895 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2896 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2897 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2898 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00002899 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00002900 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002901 }
2902
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002903 // Add preprocessing options like -I, -D, etc. if we are using the
2904 // preprocessor.
2905 //
2906 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002907 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00002908 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002909
Rafael Espindolaa7431922011-07-21 23:40:37 +00002910 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2911 // that "The compiler can only warn and ignore the option if not recognized".
2912 // When building with ccache, it will pass -D options to clang even on
2913 // preprocessed inputs and configure concludes that -fPIC is not supported.
2914 Args.ClaimAllArgs(options::OPT_D);
2915
Alp Toker7874bdc2013-11-15 20:40:58 +00002916 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00002917 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2918 if (A->getOption().matches(options::OPT_O4)) {
2919 CmdArgs.push_back("-O3");
2920 D.Diag(diag::warn_O4_is_O3);
2921 } else {
2922 A->render(Args, CmdArgs);
2923 }
2924 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002925
Chad Rosier86b82082012-12-12 20:06:31 +00002926 // Don't warn about unused -flto. This can happen when we're preprocessing or
2927 // precompiling.
2928 Args.ClaimAllArgs(options::OPT_flto);
2929
Daniel Dunbar945577c2009-10-29 02:24:45 +00002930 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00002931 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2932 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00002933 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002934 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002935
2936 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00002937 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002938 //
2939 // If a std is supplied, only add -trigraphs if it follows the
2940 // option.
2941 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2942 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00002943 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002944 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00002945 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00002946 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002947 else
2948 Std->render(Args, CmdArgs);
2949
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00002950 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2951 options::OPT_trigraphs))
2952 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002953 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002954 } else {
2955 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00002956 //
2957 // FIXME: Clang doesn't correctly handle -std= when the input language
2958 // doesn't match. For the time being just ignore this for C++ inputs;
2959 // eventually we want to do all the standard defaulting here instead of
2960 // splitting it between the driver and clang -cc1.
2961 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00002962 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2963 "-std=", /*Joined=*/true);
2964 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2965 CmdArgs.push_back("-std=c++11");
2966
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00002967 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00002968 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002969
Richard Smith282b4492013-09-04 22:50:31 +00002970 // GCC's behavior for -Wwrite-strings is a bit strange:
2971 // * In C, this "warning flag" changes the types of string literals from
2972 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2973 // for the discarded qualifier.
2974 // * In C++, this is just a normal warning flag.
2975 //
2976 // Implementing this warning correctly in C is hard, so we follow GCC's
2977 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2978 // a non-const char* in C, rather than using this crude hack.
2979 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00002980 // FIXME: This should behave just like a warning flag, and thus should also
2981 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
2982 Arg *WriteStrings =
2983 Args.getLastArg(options::OPT_Wwrite_strings,
2984 options::OPT_Wno_write_strings, options::OPT_w);
2985 if (WriteStrings &&
2986 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00002987 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00002988 }
2989
Chandler Carruth61fbf622011-04-23 09:27:53 +00002990 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00002991 // during C++ compilation, which it is by default. GCC keeps this define even
2992 // in the presence of '-w', match this behavior bug-for-bug.
2993 if (types::isCXX(InputType) &&
2994 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2995 true)) {
2996 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00002997 }
2998
Chandler Carruthe0391482010-05-22 02:21:53 +00002999 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3000 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3001 if (Asm->getOption().matches(options::OPT_fasm))
3002 CmdArgs.push_back("-fgnu-keywords");
3003 else
3004 CmdArgs.push_back("-fno-gnu-keywords");
3005 }
3006
Rafael Espindola4cfa7972011-05-02 17:43:32 +00003007 if (ShouldDisableCFI(Args, getToolChain()))
3008 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolae2641872011-04-30 18:35:43 +00003009
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003010 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3011 CmdArgs.push_back("-fno-dwarf-directory-asm");
3012
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003013 if (ShouldDisableAutolink(Args, getToolChain()))
3014 CmdArgs.push_back("-fno-autolink");
3015
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003016 // Add in -fdebug-compilation-dir if necessary.
3017 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003018
Richard Smith9a568822011-11-21 19:36:32 +00003019 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3020 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003021 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003022 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003023 }
3024
Richard Smith79c927b2013-11-06 19:31:51 +00003025 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3026 CmdArgs.push_back("-foperator-arrow-depth");
3027 CmdArgs.push_back(A->getValue());
3028 }
3029
Richard Smith9a568822011-11-21 19:36:32 +00003030 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3031 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003032 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003033 }
3034
Richard Smitha3d3bd22013-05-08 02:12:03 +00003035 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3036 CmdArgs.push_back("-fconstexpr-steps");
3037 CmdArgs.push_back(A->getValue());
3038 }
3039
Richard Smithb3a14522013-02-22 01:59:51 +00003040 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3041 CmdArgs.push_back("-fbracket-depth");
3042 CmdArgs.push_back(A->getValue());
3043 }
3044
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003045 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3046 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003047 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003048 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003049 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3050 } else
3051 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003052 }
3053
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003054
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003055 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003056 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003057
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003058 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3059 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003060 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003061 }
David Chisnall5778fce2009-08-31 16:41:57 +00003062
Chris Lattnere23003d2010-01-09 21:54:33 +00003063 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3064 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003065 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003066 }
3067
Chris Lattnerb35583d2010-04-07 20:49:23 +00003068 CmdArgs.push_back("-ferror-limit");
3069 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003070 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003071 else
3072 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003073
Chandler Carrutha77a7272010-05-06 04:55:18 +00003074 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3075 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003076 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003077 }
3078
3079 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3080 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003081 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003082 }
3083
Richard Smithf6f003a2011-12-16 19:06:07 +00003084 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3085 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003086 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003087 }
3088
Daniel Dunbar2c978472009-11-04 06:24:47 +00003089 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003090 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003091 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003092 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003093 } else {
3094 // If -fmessage-length=N was not specified, determine whether this is a
3095 // terminal and, if so, implicitly define -fmessage-length appropriately.
3096 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003097 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003098 }
3099
John McCallb4a99d32013-02-19 01:57:35 +00003100 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3101 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3102 options::OPT_fvisibility_ms_compat)) {
3103 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3104 CmdArgs.push_back("-fvisibility");
3105 CmdArgs.push_back(A->getValue());
3106 } else {
3107 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3108 CmdArgs.push_back("-fvisibility");
3109 CmdArgs.push_back("hidden");
3110 CmdArgs.push_back("-ftype-visibility");
3111 CmdArgs.push_back("default");
3112 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003113 }
3114
Douglas Gregor08329632010-06-15 17:05:35 +00003115 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003116
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003117 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3118
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003119 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003120 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3121 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003122 CmdArgs.push_back("-ffreestanding");
3123
Daniel Dunbare357d562009-12-03 18:42:11 +00003124 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003125 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003126 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003127 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3128 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003129 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003130 // AltiVec language extensions aren't relevant for assembling.
3131 if (!isa<PreprocessJobAction>(JA) ||
3132 Output.getType() != types::TY_PP_Asm)
3133 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003134 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3135 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003136
Peter Collingbourne32701642013-11-01 18:16:25 +00003137 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3138 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003139
Will Dietz3676d562012-12-30 20:53:28 +00003140 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3141 options::OPT_fno_sanitize_recover,
3142 true))
3143 CmdArgs.push_back("-fno-sanitize-recover");
3144
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003145 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003146 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3147 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3148
Eric Christopher459d2712013-02-19 06:16:53 +00003149 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003150 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003151 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003152 getToolChain().getArch() == llvm::Triple::ppc64 ||
3153 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003154 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003155 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003156
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003157 if (getToolChain().SupportsProfiling())
3158 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003159
3160 // -flax-vector-conversions is default.
3161 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3162 options::OPT_fno_lax_vector_conversions))
3163 CmdArgs.push_back("-fno-lax-vector-conversions");
3164
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003165 if (Args.getLastArg(options::OPT_fapple_kext))
3166 CmdArgs.push_back("-fapple-kext");
3167
David Blaikie690f21e2012-06-14 18:55:27 +00003168 if (Args.hasFlag(options::OPT_frewrite_includes,
3169 options::OPT_fno_rewrite_includes, false))
3170 CmdArgs.push_back("-frewrite-includes");
3171
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003172 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003173 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003174 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003175 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3176 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003177
3178 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3179 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003180 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003181 }
3182
Bob Wilson14adb362012-02-03 06:27:22 +00003183 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003184
Chandler Carruth6e501032011-03-27 00:04:55 +00003185 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3186 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3187 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3188 options::OPT_fno_wrapv)) {
3189 if (A->getOption().matches(options::OPT_fwrapv))
3190 CmdArgs.push_back("-fwrapv");
3191 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3192 options::OPT_fno_strict_overflow)) {
3193 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3194 CmdArgs.push_back("-fwrapv");
3195 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003196
3197 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3198 options::OPT_fno_reroll_loops))
3199 if (A->getOption().matches(options::OPT_freroll_loops))
3200 CmdArgs.push_back("-freroll-loops");
3201
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003202 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003203 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3204 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003205
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003206 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3207
Mahesha S6a682be42012-10-27 07:47:56 +00003208
Daniel Dunbar4930e332009-11-17 08:07:36 +00003209 // -stack-protector=0 is default.
3210 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003211 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3212 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003213 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003214 options::OPT_fstack_protector)) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003215 if (A->getOption().matches(options::OPT_fstack_protector))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003216 StackProtectorLevel = LangOptions::SSPOn;
3217 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3218 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003219 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003220 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003221 } else {
3222 StackProtectorLevel =
3223 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3224 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003225 if (StackProtectorLevel) {
3226 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003227 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003228 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003229
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003230 // --param ssp-buffer-size=
3231 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3232 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003233 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003234 if (Str.startswith("ssp-buffer-size=")) {
3235 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003236 CmdArgs.push_back("-stack-protector-buffer-size");
3237 // FIXME: Verify the argument is a valid integer.
3238 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003239 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003240 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003241 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003242 }
3243
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003244 // Translate -mstackrealign
3245 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3246 false)) {
3247 CmdArgs.push_back("-backend-option");
3248 CmdArgs.push_back("-force-align-stack");
3249 }
3250 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3251 false)) {
3252 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3253 }
3254
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003255 if (Args.hasArg(options::OPT_mstack_alignment)) {
3256 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3257 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003258 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003259 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003260 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003261 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3262 options::OPT_munaligned_access)) {
3263 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3264 CmdArgs.push_back("-backend-option");
3265 CmdArgs.push_back("-arm-strict-align");
3266 } else {
3267 CmdArgs.push_back("-backend-option");
3268 CmdArgs.push_back("-arm-no-strict-align");
3269 }
Renato Golina146a482013-08-24 14:44:41 +00003270 }
Chad Rosier60027022012-11-09 17:29:19 +00003271 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003272
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003273 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3274 options::OPT_mno_restrict_it)) {
3275 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3276 CmdArgs.push_back("-backend-option");
3277 CmdArgs.push_back("-arm-restrict-it");
3278 } else {
3279 CmdArgs.push_back("-backend-option");
3280 CmdArgs.push_back("-arm-no-restrict-it");
3281 }
3282 }
3283
Daniel Dunbard18049a2009-04-07 21:16:11 +00003284 // Forward -f options with positive and negative forms; we translate
3285 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003286 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3287 StringRef fname = A->getValue();
3288 if (!llvm::sys::fs::exists(fname))
3289 D.Diag(diag::err_drv_no_such_file) << fname;
3290 else
3291 A->render(Args, CmdArgs);
3292 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003293
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003294 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003295 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003296 CmdArgs.push_back("-fapple-kext");
3297 if (!Args.hasArg(options::OPT_fbuiltin))
3298 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003299 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003300 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003301 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003302 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003303 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003304
Nuno Lopes13c88c72009-12-16 16:59:22 +00003305 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3306 options::OPT_fno_assume_sane_operator_new))
3307 CmdArgs.push_back("-fno-assume-sane-operator-new");
3308
Daniel Dunbar4930e332009-11-17 08:07:36 +00003309 // -fblocks=0 is default.
3310 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003311 getToolChain().IsBlocksDefault()) ||
3312 (Args.hasArg(options::OPT_fgnu_runtime) &&
3313 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3314 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003315 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003316
3317 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3318 !getToolChain().hasBlocksRuntime())
3319 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003320 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003321
Douglas Gregor226173a2012-01-18 15:19:58 +00003322 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3323 // users must also pass -fcxx-modules. The latter flag will disappear once the
3324 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003325 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003326 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3327 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3328 options::OPT_fno_cxx_modules,
3329 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003330 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003331 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003332 HaveModules = true;
3333 }
3334 }
3335
Daniel Jasper07e6c402013-08-05 20:26:17 +00003336 // -fmodule-maps enables module map processing (off by default) for header
3337 // checking. It is implied by -fmodules.
3338 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3339 false)) {
3340 CmdArgs.push_back("-fmodule-maps");
3341 }
3342
Daniel Jasperac42b752013-10-21 06:34:34 +00003343 // -fmodules-decluse checks that modules used are declared so (off by
3344 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003345 if (Args.hasFlag(options::OPT_fmodules_decluse,
3346 options::OPT_fno_modules_decluse,
3347 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003348 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003349 }
3350
Daniel Jasperac42b752013-10-21 06:34:34 +00003351 // -fmodule-name specifies the module that is currently being built (or
3352 // used for header checking by -fmodule-maps).
3353 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3354 A->claim();
3355 A->render(Args, CmdArgs);
3356 }
3357
3358 // -fmodule-map-file can be used to specify a file containing module
3359 // definitions.
3360 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3361 A->claim();
3362 A->render(Args, CmdArgs);
3363 }
3364
Douglas Gregor35b04d62013-02-07 19:01:24 +00003365 // If a module path was provided, pass it along. Otherwise, use a temporary
3366 // directory.
3367 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3368 A->claim();
3369 if (HaveModules) {
3370 A->render(Args, CmdArgs);
3371 }
3372 } else if (HaveModules) {
3373 SmallString<128> DefaultModuleCache;
3374 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3375 DefaultModuleCache);
Douglas Gregor23c7d672013-03-21 21:48:48 +00003376 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3377 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00003378 const char Arg[] = "-fmodules-cache-path=";
3379 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3380 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003381 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3382 }
3383
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003384 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path)) {
3385 A->claim();
3386 if (HaveModules) {
3387 A->render(Args, CmdArgs);
3388 }
3389 }
3390
Douglas Gregor35b04d62013-02-07 19:01:24 +00003391 // Pass through all -fmodules-ignore-macro arguments.
3392 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003393 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3394 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003395
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003396 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3397
3398 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3399 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3400 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3401
3402 Args.AddLastArg(CmdArgs,
3403 options::OPT_fmodules_validate_once_per_build_session);
3404 }
3405
Ben Langmuirdcf73862014-03-12 00:06:17 +00003406 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3407
John McCalldfea9982010-04-09 19:12:06 +00003408 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003409 if (Args.hasFlag(options::OPT_fno_access_control,
3410 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003411 false))
John McCall3155f572010-04-09 19:03:51 +00003412 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003413
Anders Carlssond470fef2010-11-21 00:09:52 +00003414 // -felide-constructors is the default.
3415 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3416 options::OPT_felide_constructors,
3417 false))
3418 CmdArgs.push_back("-fno-elide-constructors");
3419
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003420 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003421 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003422 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003423 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003424
Richard Smith52be6192012-11-05 22:04:41 +00003425 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003426 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003427 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003428 Args.getLastArg(options::OPT_mkernel,
3429 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003430 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003431 D.Diag(diag::err_drv_argument_not_allowed_with)
3432 << "-fsanitize=vptr" << NoRttiArg;
3433 }
3434 }
3435
Tony Linthicum76329bf2011-12-12 21:14:55 +00003436 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003437 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003438 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003439 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003440 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003441 CmdArgs.push_back("-fshort-enums");
3442
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003443 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003444 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003445 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003446 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003447
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003448 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003449 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003450 options::OPT_fno_threadsafe_statics))
3451 CmdArgs.push_back("-fno-threadsafe-statics");
3452
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003453 // -fuse-cxa-atexit is default.
Rafael Espindolaa6775b62013-11-04 17:13:51 +00003454 if (!Args.hasFlag(
3455 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3456 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3457 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Robert Lytton6b1deb42013-11-12 10:09:22 +00003458 getToolChain().getArch() != llvm::Triple::hexagon &&
3459 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003460 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003461 CmdArgs.push_back("-fno-use-cxa-atexit");
3462
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003463 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003464 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003465 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3466 CmdArgs.push_back("-fms-extensions");
3467
Francois Pichet1b4f1632011-09-17 04:32:15 +00003468 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003469 if (Args.hasFlag(options::OPT_fms_compatibility,
3470 options::OPT_fno_ms_compatibility,
3471 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3472 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,
3479 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3480 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003481 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003482 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003483 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003484 else
3485 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3486 }
3487
3488
Eric Christopher5ecce122013-02-18 00:38:31 +00003489 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003490 if (Args.hasFlag(options::OPT_fborland_extensions,
3491 options::OPT_fno_borland_extensions, false))
3492 CmdArgs.push_back("-fborland-extensions");
3493
Francois Pichet02744872011-09-01 16:38:08 +00003494 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3495 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003496 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3497 options::OPT_fno_delayed_template_parsing,
Francois Pichet02744872011-09-01 16:38:08 +00003498 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003499 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003500
Chandler Carruthe03aa552010-04-17 20:17:31 +00003501 // -fgnu-keywords default varies depending on language; only pass if
3502 // specified.
3503 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003504 options::OPT_fno_gnu_keywords))
3505 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003506
Rafael Espindola922a6242011-06-02 17:30:53 +00003507 if (Args.hasFlag(options::OPT_fgnu89_inline,
3508 options::OPT_fno_gnu89_inline,
3509 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003510 CmdArgs.push_back("-fgnu89-inline");
3511
Chad Rosier9c76d242012-03-15 22:31:42 +00003512 if (Args.hasArg(options::OPT_fno_inline))
3513 CmdArgs.push_back("-fno-inline");
3514
Chad Rosier64d6be92012-03-06 21:17:19 +00003515 if (Args.hasArg(options::OPT_fno_inline_functions))
3516 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003517
John McCall5fb5df92012-06-20 06:18:46 +00003518 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003519
John McCall5fb5df92012-06-20 06:18:46 +00003520 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003521 // legacy is the default. Except for deployment taget of 10.5,
3522 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3523 // gets ignored silently.
3524 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003525 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3526 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003527 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003528 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003529 if (getToolChain().UseObjCMixedDispatch())
3530 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3531 else
3532 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3533 }
3534 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003535
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003536 // When ObjectiveC legacy runtime is in effect on MacOSX,
3537 // turn on the option to do Array/Dictionary subscripting
3538 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003539 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3540 getToolChain().getTriple().isMacOSX() &&
3541 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3542 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003543 objcRuntime.isNeXTFamily())
3544 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3545
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003546 // -fencode-extended-block-signature=1 is default.
3547 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3548 CmdArgs.push_back("-fencode-extended-block-signature");
3549 }
3550
John McCall24fc0de2011-07-06 00:26:06 +00003551 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3552 // NOTE: This logic is duplicated in ToolChains.cpp.
3553 bool ARC = isObjCAutoRefCount(Args);
3554 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003555 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003556
John McCall24fc0de2011-07-06 00:26:06 +00003557 CmdArgs.push_back("-fobjc-arc");
3558
Chandler Carruth491db322011-11-04 07:34:47 +00003559 // FIXME: It seems like this entire block, and several around it should be
3560 // wrapped in isObjC, but for now we just use it here as this is where it
3561 // was being used previously.
3562 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3563 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3564 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3565 else
3566 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3567 }
3568
John McCall24fc0de2011-07-06 00:26:06 +00003569 // Allow the user to enable full exceptions code emission.
3570 // We define off for Objective-CC, on for Objective-C++.
3571 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3572 options::OPT_fno_objc_arc_exceptions,
3573 /*default*/ types::isCXX(InputType)))
3574 CmdArgs.push_back("-fobjc-arc-exceptions");
3575 }
3576
3577 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3578 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003579 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003580 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003581
John McCall24fc0de2011-07-06 00:26:06 +00003582 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3583 // takes precedence.
3584 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3585 if (!GCArg)
3586 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3587 if (GCArg) {
3588 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003589 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003590 << GCArg->getAsString(Args);
3591 } else if (getToolChain().SupportsObjCGC()) {
3592 GCArg->render(Args, CmdArgs);
3593 } else {
3594 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003595 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003596 << GCArg->getAsString(Args);
3597 }
3598 }
3599
John McCallb5f652e2011-06-22 00:53:57 +00003600 // Add exception args.
3601 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003602 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003603
3604 if (getToolChain().UseSjLjExceptions())
3605 CmdArgs.push_back("-fsjlj-exceptions");
3606
3607 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003608 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3609 options::OPT_fno_assume_sane_operator_new))
3610 CmdArgs.push_back("-fno-assume-sane-operator-new");
3611
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003612 // -fconstant-cfstrings is default, and may be subject to argument translation
3613 // on Darwin.
3614 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3615 options::OPT_fno_constant_cfstrings) ||
3616 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3617 options::OPT_mno_constant_cfstrings))
3618 CmdArgs.push_back("-fno-constant-cfstrings");
3619
John Thompsoned4e2952009-11-05 20:14:16 +00003620 // -fshort-wchar default varies depending on platform; only
3621 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003622 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3623 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003624 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003625
Hans Wennborg28c96312013-07-31 23:39:13 +00003626 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003627 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003628 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003629 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003630 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003631
Daniel Dunbar096ed292011-10-05 21:04:55 +00003632 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3633 // -fno-pack-struct doesn't apply to -fpack-struct=.
3634 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003635 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003636 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003637 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003638 } else if (Args.hasFlag(options::OPT_fpack_struct,
3639 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003640 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003641 }
3642
Robert Lytton0e076492013-08-13 09:43:10 +00003643 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003644 if (!Args.hasArg(options::OPT_fcommon))
3645 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003646 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003647 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003648
Daniel Dunbard18049a2009-04-07 21:16:11 +00003649 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003650 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003651 CmdArgs.push_back("-fno-common");
3652
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003653 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003654 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003655 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003656 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003657 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003658 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3659
Daniel Dunbar6358d682010-10-15 22:30:42 +00003660 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3661 if (!Args.hasFlag(options::OPT_ffor_scope,
3662 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003663 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003664 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3665
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003666 // -fcaret-diagnostics is default.
3667 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3668 options::OPT_fno_caret_diagnostics, true))
3669 CmdArgs.push_back("-fno-caret-diagnostics");
3670
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003671 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003672 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003673 options::OPT_fno_diagnostics_fixit_info))
3674 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003675
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003676 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003677 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003678 options::OPT_fno_diagnostics_show_option))
3679 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003680
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003681 if (const Arg *A =
3682 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3683 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003684 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003685 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003686
Douglas Gregor643c9222011-05-21 17:07:29 +00003687 if (const Arg *A =
3688 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3689 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003690 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003691 }
3692
Chandler Carruthb6766f02011-03-27 01:50:55 +00003693 if (Arg *A = Args.getLastArg(
3694 options::OPT_fdiagnostics_show_note_include_stack,
3695 options::OPT_fno_diagnostics_show_note_include_stack)) {
3696 if (A->getOption().matches(
3697 options::OPT_fdiagnostics_show_note_include_stack))
3698 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3699 else
3700 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3701 }
3702
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003703 // Color diagnostics are the default, unless the terminal doesn't support
3704 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003705 // Support both clang's -f[no-]color-diagnostics and gcc's
3706 // -f[no-]diagnostics-colors[=never|always|auto].
3707 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3708 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3709 it != ie; ++it) {
3710 const Option &O = (*it)->getOption();
3711 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3712 !O.matches(options::OPT_fdiagnostics_color) &&
3713 !O.matches(options::OPT_fno_color_diagnostics) &&
3714 !O.matches(options::OPT_fno_diagnostics_color) &&
3715 !O.matches(options::OPT_fdiagnostics_color_EQ))
3716 continue;
3717
3718 (*it)->claim();
3719 if (O.matches(options::OPT_fcolor_diagnostics) ||
3720 O.matches(options::OPT_fdiagnostics_color)) {
3721 ShowColors = Colors_On;
3722 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3723 O.matches(options::OPT_fno_diagnostics_color)) {
3724 ShowColors = Colors_Off;
3725 } else {
3726 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3727 StringRef value((*it)->getValue());
3728 if (value == "always")
3729 ShowColors = Colors_On;
3730 else if (value == "never")
3731 ShowColors = Colors_Off;
3732 else if (value == "auto")
3733 ShowColors = Colors_Auto;
3734 else
3735 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3736 << ("-fdiagnostics-color=" + value).str();
3737 }
3738 }
3739 if (ShowColors == Colors_On ||
3740 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003741 CmdArgs.push_back("-fcolor-diagnostics");
3742
Nico Rieck7857d462013-09-11 00:38:02 +00003743 if (Args.hasArg(options::OPT_fansi_escape_codes))
3744 CmdArgs.push_back("-fansi-escape-codes");
3745
Daniel Dunbardb097022009-06-08 21:13:54 +00003746 if (!Args.hasFlag(options::OPT_fshow_source_location,
3747 options::OPT_fno_show_source_location))
3748 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003749
Douglas Gregor643c9222011-05-21 17:07:29 +00003750 if (!Args.hasFlag(options::OPT_fshow_column,
3751 options::OPT_fno_show_column,
3752 true))
3753 CmdArgs.push_back("-fno-show-column");
3754
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003755 if (!Args.hasFlag(options::OPT_fspell_checking,
3756 options::OPT_fno_spell_checking))
3757 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003758
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003759
Chad Rosierc8e56e82012-12-05 21:08:21 +00003760 // -fno-asm-blocks is default.
3761 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3762 false))
3763 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003764
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003765 // Enable vectorization per default according to the optimization level
3766 // selected. For optimization levels that want vectorization we use the alias
3767 // option to simplify the hasFlag logic.
3768 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3769 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003770 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003771 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003772 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003773 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003774
Rafael Espindolaf818ef42013-08-01 23:56:42 +00003775 // -fslp-vectorize is default.
3776 if (Args.hasFlag(options::OPT_fslp_vectorize,
3777 options::OPT_fno_slp_vectorize, true))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00003778 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00003779
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003780 // -fno-slp-vectorize-aggressive is default.
3781 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003782 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003783 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003784
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00003785 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3786 A->render(Args, CmdArgs);
3787
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003788 // -fdollars-in-identifiers default varies depending on platform and
3789 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003790 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003791 options::OPT_fno_dollars_in_identifiers)) {
3792 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003793 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003794 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003795 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003796 }
3797
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003798 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3799 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003800 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003801 options::OPT_fno_unit_at_a_time)) {
3802 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003803 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003804 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003805
Eli Friedman055c9702011-11-02 01:53:16 +00003806 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3807 options::OPT_fno_apple_pragma_pack, false))
3808 CmdArgs.push_back("-fapple-pragma-pack");
3809
Eli Benderskyc95cfe82013-07-24 18:20:14 +00003810 // le32-specific flags:
3811 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3812 // by default.
3813 if (getToolChain().getArch() == llvm::Triple::le32) {
3814 CmdArgs.push_back("-fno-math-builtin");
3815 }
3816
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003817 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003818 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003819 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003820#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00003821 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003822 (getToolChain().getArch() == llvm::Triple::arm ||
3823 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003824 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3825 CmdArgs.push_back("-fno-builtin-strcat");
3826 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3827 CmdArgs.push_back("-fno-builtin-strcpy");
3828 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00003829#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00003830
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003831 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00003832 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003833 options::OPT_traditional_cpp)) {
3834 if (isa<PreprocessJobAction>(JA))
3835 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003836 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003837 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00003838 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00003839
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003840 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00003841 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003842
3843 // Handle serialized diagnostics.
3844 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3845 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00003846 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00003847 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003848
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00003849 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3850 CmdArgs.push_back("-fretain-comments-from-system-headers");
3851
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003852 // Forward -fcomment-block-commands to -cc1.
3853 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00003854 // Forward -fparse-all-comments to -cc1.
3855 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00003856
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003857 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3858 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003859 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003860 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3861 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00003862 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00003863
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003864 // We translate this by hand to the -cc1 argument, since nightly test uses
3865 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00003866 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003867 CmdArgs.push_back("-disable-llvm-optzns");
3868 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00003869 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00003870 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003871
Daniel Dunbard67a3222009-03-30 06:36:42 +00003872 if (Output.getType() == types::TY_Dependencies) {
3873 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003874 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00003875 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003876 CmdArgs.push_back(Output.getFilename());
3877 } else {
3878 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003879 }
3880
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003881 for (InputInfoList::const_iterator
3882 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3883 const InputInfo &II = *it;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00003884
3885 addDashXForInput(Args, II, CmdArgs);
3886
Daniel Dunbarb440f562010-08-02 02:38:21 +00003887 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003888 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003889 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003890 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003891 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003892
Chris Lattnere9d7d782009-11-03 19:50:27 +00003893 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3894
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00003895 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003896
3897 // Optionally embed the -cc1 level arguments into the debug info, for build
3898 // analysis.
3899 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003900 ArgStringList OriginalArgs;
3901 for (ArgList::const_iterator it = Args.begin(),
3902 ie = Args.end(); it != ie; ++it)
3903 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003904
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003905 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003906 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003907 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003908 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00003909 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00003910 }
3911 CmdArgs.push_back("-dwarf-debug-flags");
3912 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3913 }
3914
Eric Christopherd3804002013-02-22 20:12:52 +00003915 // Add the split debug info name to the command lines here so we
3916 // can propagate it to the backend.
3917 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003918 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00003919 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00003920 const char *SplitDwarfOut;
3921 if (SplitDwarf) {
3922 CmdArgs.push_back("-split-dwarf-file");
3923 SplitDwarfOut = SplitDebugName(Args, Inputs);
3924 CmdArgs.push_back(SplitDwarfOut);
3925 }
3926
3927 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00003928 if (Args.hasArg(options::OPT__SLASH_fallback) &&
3929 Output.getType() == types::TY_Object) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00003930 tools::visualstudio::Compile CL(getToolChain());
3931 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3932 LinkingOutput);
3933 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3934 } else {
3935 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3936 }
3937
Daniel Dunbar17731772009-03-23 19:03:36 +00003938
Eric Christopherf1545832013-02-22 23:50:16 +00003939 // Handle the debug info splitting at object creation time if we're
3940 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00003941 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00003942 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00003943 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00003944
Roman Divacky178e01602011-02-10 16:52:03 +00003945 if (Arg *A = Args.getLastArg(options::OPT_pg))
3946 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003947 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00003948 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003949
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003950 // Claim some arguments which clang supports automatically.
3951
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00003952 // -fpch-preprocess is used with gcc to add a special marker in the output to
3953 // include the PCH file. Clang's PTH solution is completely transparent, so we
3954 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00003955 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003956
Daniel Dunbar17731772009-03-23 19:03:36 +00003957 // Claim some arguments which clang doesn't support, but we don't
3958 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00003959 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3960 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00003961
Rafael Espindolab0092d72013-09-04 19:37:35 +00003962 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00003963 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003964}
3965
John McCall5fb5df92012-06-20 06:18:46 +00003966/// Add options related to the Objective-C runtime/ABI.
3967///
3968/// Returns true if the runtime is non-fragile.
3969ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3970 ArgStringList &cmdArgs,
3971 RewriteKind rewriteKind) const {
3972 // Look for the controlling runtime option.
3973 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3974 options::OPT_fgnu_runtime,
3975 options::OPT_fobjc_runtime_EQ);
3976
3977 // Just forward -fobjc-runtime= to the frontend. This supercedes
3978 // options about fragility.
3979 if (runtimeArg &&
3980 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3981 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00003982 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00003983 if (runtime.tryParse(value)) {
3984 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3985 << value;
3986 }
3987
3988 runtimeArg->render(args, cmdArgs);
3989 return runtime;
3990 }
3991
3992 // Otherwise, we'll need the ABI "version". Version numbers are
3993 // slightly confusing for historical reasons:
3994 // 1 - Traditional "fragile" ABI
3995 // 2 - Non-fragile ABI, version 1
3996 // 3 - Non-fragile ABI, version 2
3997 unsigned objcABIVersion = 1;
3998 // If -fobjc-abi-version= is present, use that to set the version.
3999 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004000 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004001 if (value == "1")
4002 objcABIVersion = 1;
4003 else if (value == "2")
4004 objcABIVersion = 2;
4005 else if (value == "3")
4006 objcABIVersion = 3;
4007 else
4008 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4009 << value;
4010 } else {
4011 // Otherwise, determine if we are using the non-fragile ABI.
4012 bool nonFragileABIIsDefault =
4013 (rewriteKind == RK_NonFragile ||
4014 (rewriteKind == RK_None &&
4015 getToolChain().IsObjCNonFragileABIDefault()));
4016 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4017 options::OPT_fno_objc_nonfragile_abi,
4018 nonFragileABIIsDefault)) {
4019 // Determine the non-fragile ABI version to use.
4020#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4021 unsigned nonFragileABIVersion = 1;
4022#else
4023 unsigned nonFragileABIVersion = 2;
4024#endif
4025
4026 if (Arg *abiArg = args.getLastArg(
4027 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004028 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004029 if (value == "1")
4030 nonFragileABIVersion = 1;
4031 else if (value == "2")
4032 nonFragileABIVersion = 2;
4033 else
4034 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4035 << value;
4036 }
4037
4038 objcABIVersion = 1 + nonFragileABIVersion;
4039 } else {
4040 objcABIVersion = 1;
4041 }
4042 }
4043
4044 // We don't actually care about the ABI version other than whether
4045 // it's non-fragile.
4046 bool isNonFragile = objcABIVersion != 1;
4047
4048 // If we have no runtime argument, ask the toolchain for its default runtime.
4049 // However, the rewriter only really supports the Mac runtime, so assume that.
4050 ObjCRuntime runtime;
4051 if (!runtimeArg) {
4052 switch (rewriteKind) {
4053 case RK_None:
4054 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4055 break;
4056 case RK_Fragile:
4057 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4058 break;
4059 case RK_NonFragile:
4060 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4061 break;
4062 }
4063
4064 // -fnext-runtime
4065 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4066 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004067 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004068 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4069
4070 // Otherwise, build for a generic macosx port.
4071 } else {
4072 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4073 }
4074
4075 // -fgnu-runtime
4076 } else {
4077 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004078 // Legacy behaviour is to target the gnustep runtime if we are i
4079 // non-fragile mode or the GCC runtime in fragile mode.
4080 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004081 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004082 else
4083 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004084 }
4085
4086 cmdArgs.push_back(args.MakeArgString(
4087 "-fobjc-runtime=" + runtime.getAsString()));
4088 return runtime;
4089}
4090
Hans Wennborg75958c42013-08-08 00:17:41 +00004091void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4092 unsigned RTOptionID = options::OPT__SLASH_MT;
4093
Hans Wennborgf1a74252013-09-10 20:18:04 +00004094 if (Args.hasArg(options::OPT__SLASH_LDd))
4095 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4096 // but defining _DEBUG is sticky.
4097 RTOptionID = options::OPT__SLASH_MTd;
4098
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004099 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004100 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004101
Hans Wennborg75958c42013-08-08 00:17:41 +00004102 switch(RTOptionID) {
4103 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004104 if (Args.hasArg(options::OPT__SLASH_LDd))
4105 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004106 CmdArgs.push_back("-D_MT");
4107 CmdArgs.push_back("-D_DLL");
4108 CmdArgs.push_back("--dependent-lib=msvcrt");
4109 break;
4110 case options::OPT__SLASH_MDd:
4111 CmdArgs.push_back("-D_DEBUG");
4112 CmdArgs.push_back("-D_MT");
4113 CmdArgs.push_back("-D_DLL");
4114 CmdArgs.push_back("--dependent-lib=msvcrtd");
4115 break;
4116 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004117 if (Args.hasArg(options::OPT__SLASH_LDd))
4118 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004119 CmdArgs.push_back("-D_MT");
4120 CmdArgs.push_back("--dependent-lib=libcmt");
4121 break;
4122 case options::OPT__SLASH_MTd:
4123 CmdArgs.push_back("-D_DEBUG");
4124 CmdArgs.push_back("-D_MT");
4125 CmdArgs.push_back("--dependent-lib=libcmtd");
4126 break;
4127 default:
4128 llvm_unreachable("Unexpected option ID.");
4129 }
4130
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004131 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4132 // users want. The /Za flag to cl.exe turns this off, but it's not
4133 // implemented in clang.
4134 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004135
Hans Wennborg0fd62072013-08-09 00:32:23 +00004136 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4137 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004138
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004139 // RTTI is currently not supported, so disable it by default.
4140 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4141 CmdArgs.push_back("-fno-rtti");
4142
Hans Wennborgd8d49ba2014-03-25 17:50:25 +00004143 // Let -ffunction-sections imply -fdata-sections.
4144 if (Arg * A = Args.getLastArg(options::OPT_ffunction_sections,
4145 options::OPT_fno_function_sections))
4146 if (A->getOption().matches(options::OPT_ffunction_sections))
4147 CmdArgs.push_back("-fdata-sections");
4148
David Majnemer86c318f2014-02-11 21:05:00 +00004149 const Driver &D = getToolChain().getDriver();
4150 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4151 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4152 if (MostGeneralArg && BestCaseArg)
4153 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4154 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4155
4156 if (MostGeneralArg) {
4157 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4158 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4159 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4160
4161 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4162 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4163 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4164 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4165 << FirstConflict->getAsString(Args)
4166 << SecondConflict->getAsString(Args);
4167
4168 if (SingleArg)
4169 CmdArgs.push_back("-fms-memptr-rep=single");
4170 else if (MultipleArg)
4171 CmdArgs.push_back("-fms-memptr-rep=multiple");
4172 else
4173 CmdArgs.push_back("-fms-memptr-rep=virtual");
4174 }
4175
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004176 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4177 A->render(Args, CmdArgs);
4178
Hans Wennborg81f74482013-09-10 01:07:07 +00004179 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4180 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004181 if (Args.hasArg(options::OPT__SLASH_fallback))
4182 CmdArgs.push_back("msvc-fallback");
4183 else
4184 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004185 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004186}
4187
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004188void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004189 const InputInfo &Output,
4190 const InputInfoList &Inputs,
4191 const ArgList &Args,
4192 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004193 ArgStringList CmdArgs;
4194
4195 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4196 const InputInfo &Input = Inputs[0];
4197
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004198 // Don't warn about "clang -w -c foo.s"
4199 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004200 // and "clang -emit-llvm -c foo.s"
4201 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004202
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004203 // Invoke ourselves in -cc1as mode.
4204 //
4205 // FIXME: Implement custom jobs for internal actions.
4206 CmdArgs.push_back("-cc1as");
4207
4208 // Add the "effective" target triple.
4209 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004210 std::string TripleStr =
4211 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004212 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4213
4214 // Set the output mode, we currently only expect to be used as a real
4215 // assembler.
4216 CmdArgs.push_back("-filetype");
4217 CmdArgs.push_back("obj");
4218
Eric Christopher45f2e712012-12-18 00:31:10 +00004219 // Set the main file name, so that debug info works even with
4220 // -save-temps or preprocessed assembly.
4221 CmdArgs.push_back("-main-file-name");
4222 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4223
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004224 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004225 const llvm::Triple &Triple = getToolChain().getTriple();
4226 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004227 if (!CPU.empty()) {
4228 CmdArgs.push_back("-target-cpu");
4229 CmdArgs.push_back(Args.MakeArgString(CPU));
4230 }
4231
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004232 // Add the target features
4233 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004234 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004235
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004236 // Ignore explicit -force_cpusubtype_ALL option.
4237 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004238
Eric Christopherfc3ee562012-01-10 00:38:01 +00004239 // Determine the original source input.
4240 const Action *SourceAction = &JA;
4241 while (SourceAction->getKind() != Action::InputClass) {
4242 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4243 SourceAction = SourceAction->getInputs()[0];
4244 }
4245
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004246 // Forward -g and handle debug info related flags, assuming we are dealing
4247 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004248 if (SourceAction->getType() == types::TY_Asm ||
4249 SourceAction->getType() == types::TY_PP_Asm) {
4250 Args.ClaimAllArgs(options::OPT_g_Group);
4251 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4252 if (!A->getOption().matches(options::OPT_g0))
4253 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004254
4255 // Add the -fdebug-compilation-dir flag if needed.
4256 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004257
4258 // Set the AT_producer to the clang version when using the integrated
4259 // assembler on assembly source files.
4260 CmdArgs.push_back("-dwarf-debug-producer");
4261 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004262 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004263
4264 // Optionally embed the -cc1as level arguments into the debug info, for build
4265 // analysis.
4266 if (getToolChain().UseDwarfDebugFlags()) {
4267 ArgStringList OriginalArgs;
4268 for (ArgList::const_iterator it = Args.begin(),
4269 ie = Args.end(); it != ie; ++it)
4270 (*it)->render(Args, OriginalArgs);
4271
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004272 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004273 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4274 Flags += Exec;
4275 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4276 Flags += " ";
4277 Flags += OriginalArgs[i];
4278 }
4279 CmdArgs.push_back("-dwarf-debug-flags");
4280 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4281 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004282
4283 // FIXME: Add -static support, once we have it.
4284
David Blaikie372d9502014-01-17 03:17:40 +00004285 // Consume all the warning flags. Usually this would be handled more
4286 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4287 // doesn't handle that so rather than warning about unused flags that are
4288 // actually used, we'll lie by omission instead.
4289 // FIXME: Stop lying and consume only the appropriate driver flags
4290 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4291 ie = Args.filtered_end();
4292 it != ie; ++it)
4293 (*it)->claim();
4294
David Blaikie9260ed62013-07-25 21:19:01 +00004295 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4296 getToolChain().getDriver());
4297
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004298 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004299
4300 assert(Output.isFilename() && "Unexpected lipo output.");
4301 CmdArgs.push_back("-o");
4302 CmdArgs.push_back(Output.getFilename());
4303
Daniel Dunbarb440f562010-08-02 02:38:21 +00004304 assert(Input.isFilename() && "Invalid input.");
4305 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004306
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004307 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004308 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004309
4310 // Handle the debug info splitting at object creation time if we're
4311 // creating an object.
4312 // TODO: Currently only works on linux with newer objcopy.
4313 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004314 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004315 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4316 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004317}
4318
Daniel Dunbara3246a02009-03-18 08:07:30 +00004319void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004320 const InputInfo &Output,
4321 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004322 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004323 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004324 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004325 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004326
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004327 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004328 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004329 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004330 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004331 // Don't forward any -g arguments to assembly steps.
4332 if (isa<AssembleJobAction>(JA) &&
4333 A->getOption().matches(options::OPT_g_Group))
4334 continue;
4335
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004336 // Don't forward any -W arguments to assembly and link steps.
4337 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4338 A->getOption().matches(options::OPT_W_Group))
4339 continue;
4340
Daniel Dunbar2da02722009-03-19 07:55:12 +00004341 // It is unfortunate that we have to claim here, as this means
4342 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004343 // platforms using a generic gcc, even if we are just using gcc
4344 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004345 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004346 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004347 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004348 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004349
Daniel Dunbar4e295052010-01-25 22:35:08 +00004350 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004351
4352 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004353 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004354 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004355 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004356
4357 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004358 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004359 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004360 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004361 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004362 else if (Arch == llvm::Triple::ppc64le)
4363 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004364 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004365 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004366 }
4367
Daniel Dunbar5716d872009-05-02 21:41:52 +00004368 // Try to force gcc to match the tool chain we want, if we recognize
4369 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004370 //
4371 // FIXME: The triple class should directly provide the information we want
4372 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004373 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004374 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004375 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4376 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004377 CmdArgs.push_back("-m64");
4378
Daniel Dunbarb440f562010-08-02 02:38:21 +00004379 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004380 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004381 CmdArgs.push_back(Output.getFilename());
4382 } else {
4383 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004384 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004385 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004386
Tony Linthicum76329bf2011-12-12 21:14:55 +00004387 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4388 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004389
4390 // Only pass -x if gcc will understand it; otherwise hope gcc
4391 // understands the suffix correctly. The main use case this would go
4392 // wrong in is for linker inputs if they happened to have an odd
4393 // suffix; really the only way to get this to happen is a command
4394 // like '-x foobar a.c' which will treat a.c like a linker input.
4395 //
4396 // FIXME: For the linker case specifically, can we safely convert
4397 // inputs into '-Wl,' options?
4398 for (InputInfoList::const_iterator
4399 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4400 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004401
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004402 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004403 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4404 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004405 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004406 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004407 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004408 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004409 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004410 else if (II.getType() == types::TY_ModuleFile)
4411 D.Diag(diag::err_drv_no_module_support)
4412 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004413
Daniel Dunbara3246a02009-03-18 08:07:30 +00004414 if (types::canTypeBeUserSpecified(II.getType())) {
4415 CmdArgs.push_back("-x");
4416 CmdArgs.push_back(types::getTypeName(II.getType()));
4417 }
4418
Daniel Dunbarb440f562010-08-02 02:38:21 +00004419 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004420 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004421 else {
4422 const Arg &A = II.getInputArg();
4423
4424 // Reverse translate some rewritten options.
4425 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4426 CmdArgs.push_back("-lstdc++");
4427 continue;
4428 }
4429
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004430 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004431 A.render(Args, CmdArgs);
4432 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004433 }
4434
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004435 const std::string customGCCName = D.getCCCGenericGCCName();
4436 const char *GCCName;
4437 if (!customGCCName.empty())
4438 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004439 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004440 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004441 } else
4442 GCCName = "gcc";
4443
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004444 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004445 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004446 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004447}
4448
Daniel Dunbar4e295052010-01-25 22:35:08 +00004449void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4450 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004451 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004452}
4453
Daniel Dunbar4e295052010-01-25 22:35:08 +00004454void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4455 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004456 const Driver &D = getToolChain().getDriver();
4457
Daniel Dunbar4e295052010-01-25 22:35:08 +00004458 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004459 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4460 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004461 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004462 else {
4463 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004464 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004465 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004466
Daniel Dunbar4e295052010-01-25 22:35:08 +00004467 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004468 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004469}
4470
Daniel Dunbar4e295052010-01-25 22:35:08 +00004471void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4472 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004473 // The types are (hopefully) good enough.
4474}
4475
Tony Linthicum76329bf2011-12-12 21:14:55 +00004476// Hexagon tools start.
4477void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4478 ArgStringList &CmdArgs) const {
4479
4480}
4481void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4482 const InputInfo &Output,
4483 const InputInfoList &Inputs,
4484 const ArgList &Args,
4485 const char *LinkingOutput) const {
4486
4487 const Driver &D = getToolChain().getDriver();
4488 ArgStringList CmdArgs;
4489
4490 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004491 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004492 CmdArgs.push_back(Args.MakeArgString(MarchString));
4493
4494 RenderExtraToolArgs(JA, CmdArgs);
4495
4496 if (Output.isFilename()) {
4497 CmdArgs.push_back("-o");
4498 CmdArgs.push_back(Output.getFilename());
4499 } else {
4500 assert(Output.isNothing() && "Unexpected output");
4501 CmdArgs.push_back("-fsyntax-only");
4502 }
4503
Matthew Curtise8f80a12012-12-06 17:49:03 +00004504 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4505 if (!SmallDataThreshold.empty())
4506 CmdArgs.push_back(
4507 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004508
Matthew Curtise5df3812012-12-07 17:23:04 +00004509 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4510 options::OPT_Xassembler);
4511
Tony Linthicum76329bf2011-12-12 21:14:55 +00004512 // Only pass -x if gcc will understand it; otherwise hope gcc
4513 // understands the suffix correctly. The main use case this would go
4514 // wrong in is for linker inputs if they happened to have an odd
4515 // suffix; really the only way to get this to happen is a command
4516 // like '-x foobar a.c' which will treat a.c like a linker input.
4517 //
4518 // FIXME: For the linker case specifically, can we safely convert
4519 // inputs into '-Wl,' options?
4520 for (InputInfoList::const_iterator
4521 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4522 const InputInfo &II = *it;
4523
4524 // Don't try to pass LLVM or AST inputs to a generic gcc.
4525 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4526 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4527 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4528 << getToolChain().getTripleString();
4529 else if (II.getType() == types::TY_AST)
4530 D.Diag(clang::diag::err_drv_no_ast_support)
4531 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004532 else if (II.getType() == types::TY_ModuleFile)
4533 D.Diag(diag::err_drv_no_module_support)
4534 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004535
4536 if (II.isFilename())
4537 CmdArgs.push_back(II.getFilename());
4538 else
4539 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4540 II.getInputArg().render(Args, CmdArgs);
4541 }
4542
4543 const char *GCCName = "hexagon-as";
4544 const char *Exec =
4545 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4546 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4547
4548}
4549void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4550 ArgStringList &CmdArgs) const {
4551 // The types are (hopefully) good enough.
4552}
4553
4554void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4555 const InputInfo &Output,
4556 const InputInfoList &Inputs,
4557 const ArgList &Args,
4558 const char *LinkingOutput) const {
4559
Matthew Curtise689b052012-12-06 15:46:07 +00004560 const toolchains::Hexagon_TC& ToolChain =
4561 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4562 const Driver &D = ToolChain.getDriver();
4563
Tony Linthicum76329bf2011-12-12 21:14:55 +00004564 ArgStringList CmdArgs;
4565
Matthew Curtise689b052012-12-06 15:46:07 +00004566 //----------------------------------------------------------------------------
4567 //
4568 //----------------------------------------------------------------------------
4569 bool hasStaticArg = Args.hasArg(options::OPT_static);
4570 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004571 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004572 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4573 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4574 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4575 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004576
Matthew Curtise689b052012-12-06 15:46:07 +00004577 //----------------------------------------------------------------------------
4578 // Silence warnings for various options
4579 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004580
Matthew Curtise689b052012-12-06 15:46:07 +00004581 Args.ClaimAllArgs(options::OPT_g_Group);
4582 Args.ClaimAllArgs(options::OPT_emit_llvm);
4583 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4584 // handled somewhere else.
4585 Args.ClaimAllArgs(options::OPT_static_libgcc);
4586
4587 //----------------------------------------------------------------------------
4588 //
4589 //----------------------------------------------------------------------------
4590 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4591 e = ToolChain.ExtraOpts.end();
4592 i != e; ++i)
4593 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004594
Matthew Curtisf10a5952012-12-06 14:16:43 +00004595 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4596 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004597
Matthew Curtise689b052012-12-06 15:46:07 +00004598 if (buildingLib) {
4599 CmdArgs.push_back("-shared");
4600 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4601 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004602 }
4603
Matthew Curtise689b052012-12-06 15:46:07 +00004604 if (hasStaticArg)
4605 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004606
Matthew Curtise8f80a12012-12-06 17:49:03 +00004607 if (buildPIE && !buildingLib)
4608 CmdArgs.push_back("-pie");
4609
4610 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4611 if (!SmallDataThreshold.empty()) {
4612 CmdArgs.push_back(
4613 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4614 }
4615
Matthew Curtise689b052012-12-06 15:46:07 +00004616 //----------------------------------------------------------------------------
4617 //
4618 //----------------------------------------------------------------------------
4619 CmdArgs.push_back("-o");
4620 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004621
Matthew Curtise689b052012-12-06 15:46:07 +00004622 const std::string MarchSuffix = "/" + MarchString;
4623 const std::string G0Suffix = "/G0";
4624 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4625 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4626 + "/";
4627 const std::string StartFilesDir = RootDir
4628 + "hexagon/lib"
4629 + (buildingLib
4630 ? MarchG0Suffix : MarchSuffix);
4631
4632 //----------------------------------------------------------------------------
4633 // moslib
4634 //----------------------------------------------------------------------------
4635 std::vector<std::string> oslibs;
4636 bool hasStandalone= false;
4637
4638 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4639 ie = Args.filtered_end(); it != ie; ++it) {
4640 (*it)->claim();
4641 oslibs.push_back((*it)->getValue());
4642 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004643 }
Matthew Curtise689b052012-12-06 15:46:07 +00004644 if (oslibs.empty()) {
4645 oslibs.push_back("standalone");
4646 hasStandalone = true;
4647 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004648
Matthew Curtise689b052012-12-06 15:46:07 +00004649 //----------------------------------------------------------------------------
4650 // Start Files
4651 //----------------------------------------------------------------------------
4652 if (incStdLib && incStartFiles) {
4653
4654 if (!buildingLib) {
4655 if (hasStandalone) {
4656 CmdArgs.push_back(
4657 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4658 }
4659 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4660 }
4661 std::string initObj = useShared ? "/initS.o" : "/init.o";
4662 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4663 }
4664
4665 //----------------------------------------------------------------------------
4666 // Library Search Paths
4667 //----------------------------------------------------------------------------
4668 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4669 for (ToolChain::path_list::const_iterator
4670 i = LibPaths.begin(),
4671 e = LibPaths.end();
4672 i != e;
4673 ++i)
4674 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4675
4676 //----------------------------------------------------------------------------
4677 //
4678 //----------------------------------------------------------------------------
4679 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4680 Args.AddAllArgs(CmdArgs, options::OPT_e);
4681 Args.AddAllArgs(CmdArgs, options::OPT_s);
4682 Args.AddAllArgs(CmdArgs, options::OPT_t);
4683 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4684
4685 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4686
4687 //----------------------------------------------------------------------------
4688 // Libraries
4689 //----------------------------------------------------------------------------
4690 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004691 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004692 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4693 CmdArgs.push_back("-lm");
4694 }
4695
4696 CmdArgs.push_back("--start-group");
4697
4698 if (!buildingLib) {
4699 for(std::vector<std::string>::iterator i = oslibs.begin(),
4700 e = oslibs.end(); i != e; ++i)
4701 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4702 CmdArgs.push_back("-lc");
4703 }
4704 CmdArgs.push_back("-lgcc");
4705
4706 CmdArgs.push_back("--end-group");
4707 }
4708
4709 //----------------------------------------------------------------------------
4710 // End files
4711 //----------------------------------------------------------------------------
4712 if (incStdLib && incStartFiles) {
4713 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4714 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4715 }
4716
4717 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004718 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004719}
4720// Hexagon tools end.
4721
Bernard Ogden31561762013-12-12 13:27:11 +00004722/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4723//
4724// FIXME: tblgen this.
4725const char *arm::getARMCPUForMArch(const ArgList &Args,
4726 const llvm::Triple &Triple) {
4727 StringRef MArch;
4728 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4729 // Otherwise, if we have -march= choose the base CPU for that arch.
4730 MArch = A->getValue();
4731 } else {
4732 // Otherwise, use the Arch from the triple.
4733 MArch = Triple.getArchName();
4734 }
4735
4736 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004737 if (MArch == "native") {
4738 std::string CPU = llvm::sys::getHostCPUName();
4739 if (CPU != "generic") {
4740 // Translate the native cpu into the architecture. The switch below will
4741 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004742 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004743 }
4744 }
4745
4746 if (Triple.getOS() == llvm::Triple::NetBSD) {
4747 if (MArch == "armv6")
4748 return "arm1176jzf-s";
4749 }
4750
4751 const char *result = llvm::StringSwitch<const char *>(MArch)
4752 .Cases("armv2", "armv2a","arm2")
4753 .Case("armv3", "arm6")
4754 .Case("armv3m", "arm7m")
4755 .Case("armv4", "strongarm")
4756 .Case("armv4t", "arm7tdmi")
4757 .Case("thumbv4t", "arm7tdmi")
4758 .Cases("armv5", "armv5t", "arm10tdmi")
4759 .Cases("thumbv5", "thumbv5t", "arm10tdmi")
4760 .Cases("armv5e", "armv5te", "arm1022e")
4761 .Cases("thumbv5e", "thumbv5te", "arm1022e")
4762 .Case("armv5tej", "arm926ej-s")
4763 .Case("thumbv5tej", "arm926ej-s")
4764 .Cases("armv6", "armv6k", "arm1136jf-s")
4765 .Cases("thumbv6", "thumbv6k", "arm1136jf-s")
4766 .Case("armv6j", "arm1136j-s")
4767 .Case("thumbv6j", "arm1136j-s")
4768 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
4769 .Cases("thumbv6z", "thumbv6zk", "arm1176jzf-s")
4770 .Case("armv6t2", "arm1156t2-s")
4771 .Case("thumbv6t2", "arm1156t2-s")
4772 .Cases("armv6m", "armv6-m", "cortex-m0")
4773 .Case("thumbv6m", "cortex-m0")
4774 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
4775 .Cases("thumbv7", "thumbv7a", "cortex-a8")
4776 .Cases("armv7l", "armv7-l", "cortex-a8")
Bernard Ogden31561762013-12-12 13:27:11 +00004777 .Cases("armv7s", "armv7-s", "swift")
4778 .Cases("armv7r", "armv7-r", "cortex-r4")
4779 .Case("thumbv7r", "cortex-r4")
4780 .Cases("armv7m", "armv7-m", "cortex-m3")
4781 .Case("thumbv7m", "cortex-m3")
4782 .Cases("armv7em", "armv7e-m", "cortex-m4")
4783 .Cases("thumbv7em", "thumbv7e-m", "cortex-m4")
4784 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
4785 .Cases("thumbv8", "thumbv8a", "cortex-a53")
4786 .Case("ep9312", "ep9312")
4787 .Case("iwmmxt", "iwmmxt")
4788 .Case("xscale", "xscale")
4789 // If all else failed, return the most base CPU with thumb interworking
4790 // supported by LLVM.
4791 .Default(0);
4792
4793 if (result)
4794 return result;
4795
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00004796 switch (Triple.getOS()) {
4797 case llvm::Triple::NetBSD:
4798 switch (Triple.getEnvironment()) {
4799 case llvm::Triple::GNUEABIHF:
4800 case llvm::Triple::GNUEABI:
4801 case llvm::Triple::EABIHF:
4802 case llvm::Triple::EABI:
4803 return "arm926ej-s";
4804 default:
4805 return "strongarm";
4806 }
4807 default:
4808 switch (Triple.getEnvironment()) {
4809 case llvm::Triple::EABIHF:
4810 case llvm::Triple::GNUEABIHF:
4811 return "arm1176jzf-s";
4812 default:
4813 return "arm7tdmi";
4814 }
4815 }
Bernard Ogden31561762013-12-12 13:27:11 +00004816}
4817
4818/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00004819StringRef arm::getARMTargetCPU(const ArgList &Args,
4820 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00004821 // FIXME: Warn on inconsistent use of -mcpu and -march.
4822 // If we have -mcpu=, use that.
4823 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
4824 StringRef MCPU = A->getValue();
4825 // Handle -mcpu=native.
4826 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00004827 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00004828 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00004829 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00004830 }
4831
4832 return getARMCPUForMArch(Args, Triple);
4833}
4834
4835/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
4836/// CPU.
4837//
4838// FIXME: This is redundant with -mcpu, why does LLVM use this.
4839// FIXME: tblgen this, or kill it!
4840const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
4841 return llvm::StringSwitch<const char *>(CPU)
4842 .Case("strongarm", "v4")
4843 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
4844 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
4845 .Cases("arm920", "arm920t", "arm922t", "v4t")
4846 .Cases("arm940t", "ep9312","v4t")
4847 .Cases("arm10tdmi", "arm1020t", "v5")
4848 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
4849 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
4850 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
4851 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
4852 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
4853 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00004854 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00004855 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
4856 .Cases("cortex-r4", "cortex-r5", "v7r")
4857 .Case("cortex-m0", "v6m")
4858 .Case("cortex-m3", "v7m")
4859 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00004860 .Case("swift", "v7s")
4861 .Cases("cortex-a53", "cortex-a57", "v8")
4862 .Default("");
4863}
4864
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004865bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
4866 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
4867 return A && (A->getValue() == StringRef(Value));
4868}
4869
Tim Northover157d9112014-01-16 08:48:16 +00004870llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004871 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4872 // archs which Darwin doesn't use.
4873
4874 // The matching this routine does is fairly pointless, since it is neither the
4875 // complete architecture list, nor a reasonable subset. The problem is that
4876 // historically the driver driver accepts this and also ties its -march=
4877 // handling to the architecture name, so we need to be careful before removing
4878 // support for it.
4879
4880 // This code must be kept in sync with Clang's Darwin specific argument
4881 // translation.
4882
4883 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4884 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4885 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4886 .Case("ppc64", llvm::Triple::ppc64)
4887 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4888 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4889 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00004890 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004891 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00004892 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00004893 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00004894 .Cases("armv7s", "xscale", llvm::Triple::arm)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00004895 .Case("r600", llvm::Triple::r600)
4896 .Case("nvptx", llvm::Triple::nvptx)
4897 .Case("nvptx64", llvm::Triple::nvptx64)
4898 .Case("amdil", llvm::Triple::amdil)
4899 .Case("spir", llvm::Triple::spir)
4900 .Default(llvm::Triple::UnknownArch);
4901}
Tony Linthicum76329bf2011-12-12 21:14:55 +00004902
Tim Northover157d9112014-01-16 08:48:16 +00004903void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
4904 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
4905 T.setArch(Arch);
4906
4907 if (Str == "x86_64h")
4908 T.setArchName(Str);
4909 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
4910 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00004911 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00004912 }
4913}
4914
Bob Wilsondecc03e2012-11-23 06:14:39 +00004915const char *Clang::getBaseInputName(const ArgList &Args,
4916 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00004917 return Args.MakeArgString(
4918 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004919}
4920
Bob Wilsondecc03e2012-11-23 06:14:39 +00004921const char *Clang::getBaseInputStem(const ArgList &Args,
4922 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004923 const char *Str = getBaseInputName(Args, Inputs);
4924
Chris Lattner906bb902011-01-16 08:14:11 +00004925 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004926 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004927
4928 return Str;
4929}
4930
Bob Wilsondecc03e2012-11-23 06:14:39 +00004931const char *Clang::getDependencyFileName(const ArgList &Args,
4932 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004933 // FIXME: Think about this more.
4934 std::string Res;
4935
4936 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004937 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004938 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004939 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00004940 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00004941 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004942 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00004943}
4944
Daniel Dunbarbe220842009-03-20 16:06:39 +00004945void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004946 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004947 const InputInfoList &Inputs,
4948 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00004949 const char *LinkingOutput) const {
4950 ArgStringList CmdArgs;
4951
4952 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4953 const InputInfo &Input = Inputs[0];
4954
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004955 // Determine the original source input.
4956 const Action *SourceAction = &JA;
4957 while (SourceAction->getKind() != Action::InputClass) {
4958 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4959 SourceAction = SourceAction->getInputs()[0];
4960 }
4961
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004962 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00004963 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00004964 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
4965 // FIXME: at run-time detect assembler capabilities or rely on version
4966 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00004967 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00004968 const llvm::Triple &T(getToolChain().getTriple());
4969 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00004970 CmdArgs.push_back("-Q");
4971 }
Kevin Enderby319baa42013-11-18 23:30:29 +00004972
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004973 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00004974 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00004975 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004976 if (Args.hasArg(options::OPT_gstabs))
4977 CmdArgs.push_back("--gstabs");
4978 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00004979 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00004980 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004981
Daniel Dunbarbe220842009-03-20 16:06:39 +00004982 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00004983 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00004984
Daniel Dunbar6d484762010-07-22 01:47:22 +00004985 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004986 if (getToolChain().getArch() == llvm::Triple::x86 ||
4987 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00004988 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4989 CmdArgs.push_back("-force_cpusubtype_ALL");
4990
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004991 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004992 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00004993 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00004994 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00004995 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004996 CmdArgs.push_back("-static");
4997
Daniel Dunbarbe220842009-03-20 16:06:39 +00004998 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4999 options::OPT_Xassembler);
5000
5001 assert(Output.isFilename() && "Unexpected lipo output.");
5002 CmdArgs.push_back("-o");
5003 CmdArgs.push_back(Output.getFilename());
5004
Daniel Dunbarb440f562010-08-02 02:38:21 +00005005 assert(Input.isFilename() && "Invalid input.");
5006 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005007
5008 // asm_final spec is empty.
5009
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005010 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005011 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005012 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005013}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005014
Tim Northover157d9112014-01-16 08:48:16 +00005015void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005016
Tim Northover157d9112014-01-16 08:48:16 +00005017void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5018 ArgStringList &CmdArgs) const {
5019 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005020
Daniel Dunbarc1964212009-03-26 16:23:12 +00005021 // Derived from darwin_arch spec.
5022 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005023 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005024
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005025 // FIXME: Is this needed anymore?
5026 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005027 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005028}
5029
Bill Wendling3b2000f2012-10-02 18:02:50 +00005030bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5031 // We only need to generate a temp path for LTO if we aren't compiling object
5032 // files. When compiling source files, we run 'dsymutil' after linking. We
5033 // don't run 'dsymutil' when compiling object files.
5034 for (InputInfoList::const_iterator
5035 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
5036 if (it->getType() != types::TY_Object)
5037 return true;
5038
5039 return false;
5040}
5041
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005042void darwin::Link::AddLinkArgs(Compilation &C,
5043 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005044 ArgStringList &CmdArgs,
5045 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005046 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005047 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005048
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005049 unsigned Version[3] = { 0, 0, 0 };
5050 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5051 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005052 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005053 Version[1], Version[2], HadExtra) ||
5054 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005055 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005056 << A->getAsString(Args);
5057 }
5058
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005059 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005060 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005061 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5062 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005063
Bob Wilson3d27dad2013-08-02 22:25:34 +00005064 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5065 CmdArgs.push_back("-export_dynamic");
5066
Bill Wendling313b6bf2012-11-16 23:03:00 +00005067 // If we are using LTO, then automatically create a temporary file path for
5068 // the linker to use, so that it's lifetime will extend past a possible
5069 // dsymutil step.
5070 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5071 const char *TmpPath = C.getArgs().MakeArgString(
5072 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5073 C.addTempFile(TmpPath);
5074 CmdArgs.push_back("-object_path_lto");
5075 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005076 }
5077
Daniel Dunbarc1964212009-03-26 16:23:12 +00005078 // Derived from the "link" spec.
5079 Args.AddAllArgs(CmdArgs, options::OPT_static);
5080 if (!Args.hasArg(options::OPT_static))
5081 CmdArgs.push_back("-dynamic");
5082 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5083 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5084 // here. How do we wish to handle such things?
5085 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005086
Daniel Dunbarc1964212009-03-26 16:23:12 +00005087 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005088 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005089 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005090 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005091
5092 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5093 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5094 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5095
5096 Arg *A;
5097 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5098 (A = Args.getLastArg(options::OPT_current__version)) ||
5099 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005100 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005101 << A->getAsString(Args) << "-dynamiclib";
5102
5103 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5104 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5105 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5106 } else {
5107 CmdArgs.push_back("-dylib");
5108
5109 Arg *A;
5110 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5111 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5112 (A = Args.getLastArg(options::OPT_client__name)) ||
5113 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5114 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5115 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005116 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005117 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005118
Daniel Dunbarc1964212009-03-26 16:23:12 +00005119 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5120 "-dylib_compatibility_version");
5121 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5122 "-dylib_current_version");
5123
Tim Northover157d9112014-01-16 08:48:16 +00005124 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005125
5126 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5127 "-dylib_install_name");
5128 }
5129
5130 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5131 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5132 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005133 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005134 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005135 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5136 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5137 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5138 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5139 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5140 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005141 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005142 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5143 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5144 Args.AddAllArgs(CmdArgs, options::OPT_init);
5145
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005146 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005147 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005148
Daniel Dunbarc1964212009-03-26 16:23:12 +00005149 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5150 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5151 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5152 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5153 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005154
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005155 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5156 options::OPT_fno_pie,
5157 options::OPT_fno_PIE)) {
5158 if (A->getOption().matches(options::OPT_fpie) ||
5159 A->getOption().matches(options::OPT_fPIE))
5160 CmdArgs.push_back("-pie");
5161 else
5162 CmdArgs.push_back("-no_pie");
5163 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005164
5165 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5166 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5167 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5168 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5169 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5170 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5171 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5172 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5173 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5174 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5175 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5176 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5177 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5178 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5179 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5180 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005181
Daniel Dunbar84384642011-05-02 21:03:47 +00005182 // Give --sysroot= preference, over the Apple specific behavior to also use
5183 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005184 StringRef sysroot = C.getSysRoot();
5185 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005186 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005187 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005188 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5189 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005190 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005191 }
5192
Daniel Dunbarc1964212009-03-26 16:23:12 +00005193 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5194 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5195 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5196 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5197 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005198 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005199 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5200 Args.AddAllArgs(CmdArgs, options::OPT_y);
5201 Args.AddLastArg(CmdArgs, options::OPT_w);
5202 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5203 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5204 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5205 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5206 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5207 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5208 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5209 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5210 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5211 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5212 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5213 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5214}
5215
Alexey Bataev186b28a2014-03-06 05:43:53 +00005216enum LibOpenMP {
5217 LibUnknown,
5218 LibGOMP,
5219 LibIOMP5
5220};
5221
Daniel Dunbarc1964212009-03-26 16:23:12 +00005222void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005223 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005224 const InputInfoList &Inputs,
5225 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005226 const char *LinkingOutput) const {
5227 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005228
Daniel Dunbarc1964212009-03-26 16:23:12 +00005229 // The logic here is derived from gcc's behavior; most of which
5230 // comes from specs (starting with link_command). Consult gcc for
5231 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005232 ArgStringList CmdArgs;
5233
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005234 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5235 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5236 options::OPT_ccc_arcmt_migrate)) {
5237 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
5238 (*I)->claim();
5239 const char *Exec =
5240 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5241 CmdArgs.push_back(Output.getFilename());
5242 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5243 return;
5244 }
5245
Daniel Dunbarc1964212009-03-26 16:23:12 +00005246 // I'm not sure why this particular decomposition exists in gcc, but
5247 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005248 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005249
Daniel Dunbarc1964212009-03-26 16:23:12 +00005250 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5251 Args.AddAllArgs(CmdArgs, options::OPT_s);
5252 Args.AddAllArgs(CmdArgs, options::OPT_t);
5253 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5254 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005255 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005256 Args.AddAllArgs(CmdArgs, options::OPT_r);
5257
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005258 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5259 // members of static archive libraries which implement Objective-C classes or
5260 // categories.
5261 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5262 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005263
Daniel Dunbarc1964212009-03-26 16:23:12 +00005264 CmdArgs.push_back("-o");
5265 CmdArgs.push_back(Output.getFilename());
5266
Chad Rosier06fd3c62012-05-16 23:45:12 +00005267 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005268 !Args.hasArg(options::OPT_nostartfiles))
5269 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005270
5271 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005272
Alexey Bataev186b28a2014-03-06 05:43:53 +00005273 LibOpenMP UsedOpenMPLib = LibUnknown;
5274 if (Args.hasArg(options::OPT_fopenmp)) {
5275 UsedOpenMPLib = LibGOMP;
5276 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5277 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5278 .Case("libgomp", LibGOMP)
5279 .Case("libiomp5", LibIOMP5)
5280 .Default(LibUnknown);
5281 if (UsedOpenMPLib == LibUnknown)
5282 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5283 << A->getOption().getName() << A->getValue();
5284 }
5285 switch (UsedOpenMPLib) {
5286 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005287 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005288 break;
5289 case LibIOMP5:
5290 CmdArgs.push_back("-liomp5");
5291 break;
5292 case LibUnknown:
5293 break;
5294 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005295
Douglas Gregor9295df02012-05-15 21:00:27 +00005296 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5297
Bob Wilson16d93952012-05-15 18:57:39 +00005298 if (isObjCRuntimeLinked(Args) &&
5299 !Args.hasArg(options::OPT_nostdlib) &&
5300 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005301 // We use arclite library for both ARC and subscripting support.
5302 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5303
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005304 CmdArgs.push_back("-framework");
5305 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005306 // Link libobj.
5307 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005308 }
John McCall31168b02011-06-15 23:02:42 +00005309
Daniel Dunbarc1964212009-03-26 16:23:12 +00005310 if (LinkingOutput) {
5311 CmdArgs.push_back("-arch_multiple");
5312 CmdArgs.push_back("-final_output");
5313 CmdArgs.push_back(LinkingOutput);
5314 }
5315
Daniel Dunbarc1964212009-03-26 16:23:12 +00005316 if (Args.hasArg(options::OPT_fnested_functions))
5317 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005318
Daniel Dunbarc1964212009-03-26 16:23:12 +00005319 if (!Args.hasArg(options::OPT_nostdlib) &&
5320 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005321 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005322 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005323
Daniel Dunbarc1964212009-03-26 16:23:12 +00005324 // link_ssp spec is empty.
5325
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005326 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005327 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005328 }
5329
Chad Rosier06fd3c62012-05-16 23:45:12 +00005330 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005331 !Args.hasArg(options::OPT_nostartfiles)) {
5332 // endfile_spec is empty.
5333 }
5334
5335 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5336 Args.AddAllArgs(CmdArgs, options::OPT_F);
5337
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005338 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005339 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005340 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005341}
5342
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005343void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005344 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005345 const InputInfoList &Inputs,
5346 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005347 const char *LinkingOutput) const {
5348 ArgStringList CmdArgs;
5349
5350 CmdArgs.push_back("-create");
5351 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005352
5353 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005354 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005355
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005356 for (InputInfoList::const_iterator
5357 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5358 const InputInfo &II = *it;
5359 assert(II.isFilename() && "Unexpected lipo input.");
5360 CmdArgs.push_back(II.getFilename());
5361 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005362 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005363 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005364 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005365}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005366
Daniel Dunbar88299622010-06-04 18:28:36 +00005367void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005368 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005369 const InputInfoList &Inputs,
5370 const ArgList &Args,
5371 const char *LinkingOutput) const {
5372 ArgStringList CmdArgs;
5373
Daniel Dunbareb86b042011-05-09 17:23:16 +00005374 CmdArgs.push_back("-o");
5375 CmdArgs.push_back(Output.getFilename());
5376
Daniel Dunbar88299622010-06-04 18:28:36 +00005377 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5378 const InputInfo &Input = Inputs[0];
5379 assert(Input.isFilename() && "Unexpected dsymutil input.");
5380 CmdArgs.push_back(Input.getFilename());
5381
Daniel Dunbar88299622010-06-04 18:28:36 +00005382 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005383 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005384 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005385}
5386
Eric Christopher551ef452011-08-23 17:56:55 +00005387void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005388 const InputInfo &Output,
5389 const InputInfoList &Inputs,
5390 const ArgList &Args,
5391 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005392 ArgStringList CmdArgs;
5393 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005394 CmdArgs.push_back("--debug-info");
5395 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005396 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005397
5398 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5399 const InputInfo &Input = Inputs[0];
5400 assert(Input.isFilename() && "Unexpected verify input");
5401
5402 // Grabbing the output of the earlier dsymutil run.
5403 CmdArgs.push_back(Input.getFilename());
5404
5405 const char *Exec =
5406 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5407 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5408}
5409
David Chisnallf571cde2012-02-15 13:39:01 +00005410void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5411 const InputInfo &Output,
5412 const InputInfoList &Inputs,
5413 const ArgList &Args,
5414 const char *LinkingOutput) const {
5415 ArgStringList CmdArgs;
5416
5417 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5418 options::OPT_Xassembler);
5419
5420 CmdArgs.push_back("-o");
5421 CmdArgs.push_back(Output.getFilename());
5422
5423 for (InputInfoList::const_iterator
5424 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5425 const InputInfo &II = *it;
5426 CmdArgs.push_back(II.getFilename());
5427 }
5428
5429 const char *Exec =
5430 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5431 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5432}
5433
5434
5435void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5436 const InputInfo &Output,
5437 const InputInfoList &Inputs,
5438 const ArgList &Args,
5439 const char *LinkingOutput) const {
5440 // FIXME: Find a real GCC, don't hard-code versions here
5441 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5442 const llvm::Triple &T = getToolChain().getTriple();
5443 std::string LibPath = "/usr/lib/";
5444 llvm::Triple::ArchType Arch = T.getArch();
5445 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005446 case llvm::Triple::x86:
5447 GCCLibPath +=
5448 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5449 break;
5450 case llvm::Triple::x86_64:
5451 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5452 GCCLibPath += "/4.5.2/amd64/";
5453 LibPath += "amd64/";
5454 break;
5455 default:
5456 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005457 }
5458
5459 ArgStringList CmdArgs;
5460
David Chisnall272a0712012-02-29 15:06:12 +00005461 // Demangle C++ names in errors
5462 CmdArgs.push_back("-C");
5463
David Chisnallf571cde2012-02-15 13:39:01 +00005464 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5465 (!Args.hasArg(options::OPT_shared))) {
5466 CmdArgs.push_back("-e");
5467 CmdArgs.push_back("_start");
5468 }
5469
5470 if (Args.hasArg(options::OPT_static)) {
5471 CmdArgs.push_back("-Bstatic");
5472 CmdArgs.push_back("-dn");
5473 } else {
5474 CmdArgs.push_back("-Bdynamic");
5475 if (Args.hasArg(options::OPT_shared)) {
5476 CmdArgs.push_back("-shared");
5477 } else {
5478 CmdArgs.push_back("--dynamic-linker");
5479 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5480 }
5481 }
5482
5483 if (Output.isFilename()) {
5484 CmdArgs.push_back("-o");
5485 CmdArgs.push_back(Output.getFilename());
5486 } else {
5487 assert(Output.isNothing() && "Invalid output.");
5488 }
5489
5490 if (!Args.hasArg(options::OPT_nostdlib) &&
5491 !Args.hasArg(options::OPT_nostartfiles)) {
5492 if (!Args.hasArg(options::OPT_shared)) {
5493 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5494 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005495 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005496 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5497 } else {
5498 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005499 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5500 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005501 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005502 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005503 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005504 }
5505
5506 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5507
5508 Args.AddAllArgs(CmdArgs, options::OPT_L);
5509 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5510 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005511 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005512
5513 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5514
5515 if (!Args.hasArg(options::OPT_nostdlib) &&
5516 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005517 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005518 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005519 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005520 if (!Args.hasArg(options::OPT_shared)) {
5521 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005522 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005523 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005524 }
David Chisnallf571cde2012-02-15 13:39:01 +00005525 }
5526
5527 if (!Args.hasArg(options::OPT_nostdlib) &&
5528 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005529 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005530 }
David Chisnall96de9932012-02-16 16:00:47 +00005531 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005532
Alexey Samsonov7811d192014-02-20 13:57:37 +00005533 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005534
5535 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005536 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005537 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5538}
5539
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005540void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005541 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005542 const InputInfoList &Inputs,
5543 const ArgList &Args,
5544 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005545 ArgStringList CmdArgs;
5546
5547 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5548 options::OPT_Xassembler);
5549
5550 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005551 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005552
5553 for (InputInfoList::const_iterator
5554 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5555 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005556 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005557 }
5558
5559 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005560 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005561 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005562}
5563
5564void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005565 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005566 const InputInfoList &Inputs,
5567 const ArgList &Args,
5568 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005569 ArgStringList CmdArgs;
5570
5571 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005572 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005573 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005574 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005575 }
5576
5577 if (Args.hasArg(options::OPT_static)) {
5578 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005579 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005580 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005581// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005582 CmdArgs.push_back("-Bdynamic");
5583 if (Args.hasArg(options::OPT_shared)) {
5584 CmdArgs.push_back("-shared");
5585 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005586 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005587 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5588 }
5589 }
5590
Daniel Dunbarb440f562010-08-02 02:38:21 +00005591 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005592 CmdArgs.push_back("-o");
5593 CmdArgs.push_back(Output.getFilename());
5594 } else {
5595 assert(Output.isNothing() && "Invalid output.");
5596 }
5597
5598 if (!Args.hasArg(options::OPT_nostdlib) &&
5599 !Args.hasArg(options::OPT_nostartfiles)) {
5600 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005601 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005602 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005603 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005604 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005605 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005606 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005607 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005608 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005609 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005610 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005611 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005612 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005613 }
5614
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005615 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5616 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005617 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005618
5619 Args.AddAllArgs(CmdArgs, options::OPT_L);
5620 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5621 Args.AddAllArgs(CmdArgs, options::OPT_e);
5622
Daniel Dunbar54423b22010-09-17 00:24:54 +00005623 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005624
5625 if (!Args.hasArg(options::OPT_nostdlib) &&
5626 !Args.hasArg(options::OPT_nodefaultlibs)) {
5627 // FIXME: For some reason GCC passes -lgcc before adding
5628 // the default system libraries. Just mimic this for now.
5629 CmdArgs.push_back("-lgcc");
5630
5631 if (Args.hasArg(options::OPT_pthread))
5632 CmdArgs.push_back("-pthread");
5633 if (!Args.hasArg(options::OPT_shared))
5634 CmdArgs.push_back("-lc");
5635 CmdArgs.push_back("-lgcc");
5636 }
5637
5638 if (!Args.hasArg(options::OPT_nostdlib) &&
5639 !Args.hasArg(options::OPT_nostartfiles)) {
5640 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005641 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005642 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005643 }
5644
Alexey Samsonov7811d192014-02-20 13:57:37 +00005645 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005646
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005647 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005648 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005649 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005650}
5651
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005652void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005653 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005654 const InputInfoList &Inputs,
5655 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005656 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005657 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005658 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005659
Rafael Espindolacc126272014-02-28 01:55:21 +00005660 switch (getToolChain().getArch()) {
5661 case llvm::Triple::x86:
5662 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5663 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005664 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005665 break;
5666
5667 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005668 CmdArgs.push_back("-mppc");
5669 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005670 break;
5671
5672 case llvm::Triple::sparc:
5673 CmdArgs.push_back("-32");
5674 NeedsKPIC = true;
5675 break;
5676
5677 case llvm::Triple::sparcv9:
5678 CmdArgs.push_back("-64");
5679 CmdArgs.push_back("-Av9a");
5680 NeedsKPIC = true;
5681 break;
5682
5683 case llvm::Triple::mips64:
5684 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005685 StringRef CPUName;
5686 StringRef ABIName;
5687 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5688
5689 CmdArgs.push_back("-mabi");
5690 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5691
5692 if (getToolChain().getArch() == llvm::Triple::mips64)
5693 CmdArgs.push_back("-EB");
5694 else
5695 CmdArgs.push_back("-EL");
5696
Rafael Espindolacc126272014-02-28 01:55:21 +00005697 NeedsKPIC = true;
5698 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005699 }
5700
Rafael Espindolacc126272014-02-28 01:55:21 +00005701 default:
5702 break;
5703 }
5704
5705 if (NeedsKPIC)
5706 addAssemblerKPIC(Args, CmdArgs);
5707
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005708 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5709 options::OPT_Xassembler);
5710
5711 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005712 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005713
5714 for (InputInfoList::const_iterator
5715 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5716 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005717 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005718 }
5719
5720 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005721 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005722 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005723}
5724
5725void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005726 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005727 const InputInfoList &Inputs,
5728 const ArgList &Args,
5729 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005730 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005731 ArgStringList CmdArgs;
5732
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005733 // Silence warning for "clang -g foo.o -o foo"
5734 Args.ClaimAllArgs(options::OPT_g_Group);
5735 // and "clang -emit-llvm foo.o -o foo"
5736 Args.ClaimAllArgs(options::OPT_emit_llvm);
5737 // and for "clang -w foo.o -o foo". Other warning options are already
5738 // handled somewhere else.
5739 Args.ClaimAllArgs(options::OPT_w);
5740
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005741 if (getToolChain().getArch() == llvm::Triple::mips64)
5742 CmdArgs.push_back("-EB");
5743 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5744 CmdArgs.push_back("-EL");
5745
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005746 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005747 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005748 CmdArgs.push_back("-e");
5749 CmdArgs.push_back("__start");
5750 }
5751
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005752 if (Args.hasArg(options::OPT_static)) {
5753 CmdArgs.push_back("-Bstatic");
5754 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005755 if (Args.hasArg(options::OPT_rdynamic))
5756 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005757 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005758 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005759 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005760 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005761 } else {
5762 CmdArgs.push_back("-dynamic-linker");
5763 CmdArgs.push_back("/usr/libexec/ld.so");
5764 }
5765 }
5766
Rafael Espindola044f7832013-06-05 04:28:55 +00005767 if (Args.hasArg(options::OPT_nopie))
5768 CmdArgs.push_back("-nopie");
5769
Daniel Dunbarb440f562010-08-02 02:38:21 +00005770 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005771 CmdArgs.push_back("-o");
5772 CmdArgs.push_back(Output.getFilename());
5773 } else {
5774 assert(Output.isNothing() && "Invalid output.");
5775 }
5776
5777 if (!Args.hasArg(options::OPT_nostdlib) &&
5778 !Args.hasArg(options::OPT_nostartfiles)) {
5779 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00005780 if (Args.hasArg(options::OPT_pg))
5781 CmdArgs.push_back(Args.MakeArgString(
5782 getToolChain().GetFilePath("gcrt0.o")));
5783 else
5784 CmdArgs.push_back(Args.MakeArgString(
5785 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005786 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005787 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005788 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005789 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005790 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005791 }
5792 }
5793
Edward O'Callaghan5c521462009-10-28 15:13:08 +00005794 std::string Triple = getToolChain().getTripleString();
5795 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005796 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005797 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005798 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005799
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005800 Args.AddAllArgs(CmdArgs, options::OPT_L);
5801 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5802 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005803 Args.AddAllArgs(CmdArgs, options::OPT_s);
5804 Args.AddAllArgs(CmdArgs, options::OPT_t);
5805 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5806 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005807
Daniel Dunbar54423b22010-09-17 00:24:54 +00005808 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005809
5810 if (!Args.hasArg(options::OPT_nostdlib) &&
5811 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005812 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005813 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00005814 if (Args.hasArg(options::OPT_pg))
5815 CmdArgs.push_back("-lm_p");
5816 else
5817 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00005818 }
5819
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005820 // FIXME: For some reason GCC passes -lgcc before adding
5821 // the default system libraries. Just mimic this for now.
5822 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005823
Eric Christopher17674ec2012-09-13 06:32:34 +00005824 if (Args.hasArg(options::OPT_pthread)) {
5825 if (!Args.hasArg(options::OPT_shared) &&
5826 Args.hasArg(options::OPT_pg))
5827 CmdArgs.push_back("-lpthread_p");
5828 else
5829 CmdArgs.push_back("-lpthread");
5830 }
5831
Chandler Carruth45661652011-12-17 22:32:42 +00005832 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00005833 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00005834 CmdArgs.push_back("-lc_p");
5835 else
5836 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00005837 }
Eric Christopher17674ec2012-09-13 06:32:34 +00005838
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005839 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005840 }
5841
5842 if (!Args.hasArg(options::OPT_nostdlib) &&
5843 !Args.hasArg(options::OPT_nostartfiles)) {
5844 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005845 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005846 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005847 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00005848 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005849 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005850 }
5851
5852 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005853 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005854 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005855}
Ed Schoutene33194b2009-04-02 19:13:12 +00005856
Eli Friedman9fa28852012-08-08 23:57:20 +00005857void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5858 const InputInfo &Output,
5859 const InputInfoList &Inputs,
5860 const ArgList &Args,
5861 const char *LinkingOutput) const {
5862 ArgStringList CmdArgs;
5863
5864 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5865 options::OPT_Xassembler);
5866
5867 CmdArgs.push_back("-o");
5868 CmdArgs.push_back(Output.getFilename());
5869
5870 for (InputInfoList::const_iterator
5871 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5872 const InputInfo &II = *it;
5873 CmdArgs.push_back(II.getFilename());
5874 }
5875
5876 const char *Exec =
5877 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5878 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5879}
5880
5881void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5882 const InputInfo &Output,
5883 const InputInfoList &Inputs,
5884 const ArgList &Args,
5885 const char *LinkingOutput) const {
5886 const Driver &D = getToolChain().getDriver();
5887 ArgStringList CmdArgs;
5888
5889 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5890 (!Args.hasArg(options::OPT_shared))) {
5891 CmdArgs.push_back("-e");
5892 CmdArgs.push_back("__start");
5893 }
5894
5895 if (Args.hasArg(options::OPT_static)) {
5896 CmdArgs.push_back("-Bstatic");
5897 } else {
5898 if (Args.hasArg(options::OPT_rdynamic))
5899 CmdArgs.push_back("-export-dynamic");
5900 CmdArgs.push_back("--eh-frame-hdr");
5901 CmdArgs.push_back("-Bdynamic");
5902 if (Args.hasArg(options::OPT_shared)) {
5903 CmdArgs.push_back("-shared");
5904 } else {
5905 CmdArgs.push_back("-dynamic-linker");
5906 CmdArgs.push_back("/usr/libexec/ld.so");
5907 }
5908 }
5909
5910 if (Output.isFilename()) {
5911 CmdArgs.push_back("-o");
5912 CmdArgs.push_back(Output.getFilename());
5913 } else {
5914 assert(Output.isNothing() && "Invalid output.");
5915 }
5916
5917 if (!Args.hasArg(options::OPT_nostdlib) &&
5918 !Args.hasArg(options::OPT_nostartfiles)) {
5919 if (!Args.hasArg(options::OPT_shared)) {
5920 if (Args.hasArg(options::OPT_pg))
5921 CmdArgs.push_back(Args.MakeArgString(
5922 getToolChain().GetFilePath("gcrt0.o")));
5923 else
5924 CmdArgs.push_back(Args.MakeArgString(
5925 getToolChain().GetFilePath("crt0.o")));
5926 CmdArgs.push_back(Args.MakeArgString(
5927 getToolChain().GetFilePath("crtbegin.o")));
5928 } else {
5929 CmdArgs.push_back(Args.MakeArgString(
5930 getToolChain().GetFilePath("crtbeginS.o")));
5931 }
5932 }
5933
5934 Args.AddAllArgs(CmdArgs, options::OPT_L);
5935 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5936 Args.AddAllArgs(CmdArgs, options::OPT_e);
5937
5938 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5939
5940 if (!Args.hasArg(options::OPT_nostdlib) &&
5941 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005942 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00005943 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5944 if (Args.hasArg(options::OPT_pg))
5945 CmdArgs.push_back("-lm_p");
5946 else
5947 CmdArgs.push_back("-lm");
5948 }
5949
Rafael Espindola1ad26f02012-10-23 17:07:31 +00005950 if (Args.hasArg(options::OPT_pthread)) {
5951 if (!Args.hasArg(options::OPT_shared) &&
5952 Args.hasArg(options::OPT_pg))
5953 CmdArgs.push_back("-lpthread_p");
5954 else
5955 CmdArgs.push_back("-lpthread");
5956 }
5957
Eli Friedman9fa28852012-08-08 23:57:20 +00005958 if (!Args.hasArg(options::OPT_shared)) {
5959 if (Args.hasArg(options::OPT_pg))
5960 CmdArgs.push_back("-lc_p");
5961 else
5962 CmdArgs.push_back("-lc");
5963 }
5964
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005965 StringRef MyArch;
5966 switch (getToolChain().getTriple().getArch()) {
5967 case llvm::Triple::arm:
5968 MyArch = "arm";
5969 break;
5970 case llvm::Triple::x86:
5971 MyArch = "i386";
5972 break;
5973 case llvm::Triple::x86_64:
5974 MyArch = "amd64";
5975 break;
5976 default:
5977 llvm_unreachable("Unsupported architecture");
5978 }
5979 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00005980 }
5981
5982 if (!Args.hasArg(options::OPT_nostdlib) &&
5983 !Args.hasArg(options::OPT_nostartfiles)) {
5984 if (!Args.hasArg(options::OPT_shared))
5985 CmdArgs.push_back(Args.MakeArgString(
5986 getToolChain().GetFilePath("crtend.o")));
5987 else
5988 CmdArgs.push_back(Args.MakeArgString(
5989 getToolChain().GetFilePath("crtendS.o")));
5990 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005991
5992 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005993 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00005994 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00005995}
5996
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005997void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005998 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005999 const InputInfoList &Inputs,
6000 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006001 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006002 ArgStringList CmdArgs;
6003
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006004 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6005 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006006 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006007 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006008 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006009 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006010 else if (getToolChain().getArch() == llvm::Triple::mips ||
6011 getToolChain().getArch() == llvm::Triple::mipsel ||
6012 getToolChain().getArch() == llvm::Triple::mips64 ||
6013 getToolChain().getArch() == llvm::Triple::mips64el) {
6014 StringRef CPUName;
6015 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006016 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006017
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006018 CmdArgs.push_back("-march");
6019 CmdArgs.push_back(CPUName.data());
6020
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006021 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006022 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006023
6024 if (getToolChain().getArch() == llvm::Triple::mips ||
6025 getToolChain().getArch() == llvm::Triple::mips64)
6026 CmdArgs.push_back("-EB");
6027 else
6028 CmdArgs.push_back("-EL");
6029
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006030 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006031 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6032 getToolChain().getArch() == llvm::Triple::thumb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006033 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006034 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006035 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6036
6037 if (FloatABI == "hard") {
6038 CmdArgs.push_back("-mfpu=vfp");
6039 } else {
6040 CmdArgs.push_back("-mfpu=softvfp");
6041 }
6042
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006043 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006044 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006045 case llvm::Triple::GNUEABI:
6046 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006047 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006048 break;
6049
6050 default:
6051 CmdArgs.push_back("-matpcs");
6052 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006053 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006054 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006055 if (getToolChain().getArch() == llvm::Triple::sparc)
6056 CmdArgs.push_back("-Av8plusa");
6057 else
6058 CmdArgs.push_back("-Av9a");
6059
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006060 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006061 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006062
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006063 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6064 options::OPT_Xassembler);
6065
6066 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006067 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006068
6069 for (InputInfoList::const_iterator
6070 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6071 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006072 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006073 }
6074
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006075 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006076 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006077 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006078}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006079
6080void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006081 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006082 const InputInfoList &Inputs,
6083 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006084 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006085 const toolchains::FreeBSD& ToolChain =
6086 static_cast<const toolchains::FreeBSD&>(getToolChain());
6087 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006088 const bool IsPIE =
6089 !Args.hasArg(options::OPT_shared) &&
6090 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006091 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006092
6093 // Silence warning for "clang -g foo.o -o foo"
6094 Args.ClaimAllArgs(options::OPT_g_Group);
6095 // and "clang -emit-llvm foo.o -o foo"
6096 Args.ClaimAllArgs(options::OPT_emit_llvm);
6097 // and for "clang -w foo.o -o foo". Other warning options are already
6098 // handled somewhere else.
6099 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006100
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006101 if (!D.SysRoot.empty())
6102 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6103
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006104 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006105 CmdArgs.push_back("-pie");
6106
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006107 if (Args.hasArg(options::OPT_static)) {
6108 CmdArgs.push_back("-Bstatic");
6109 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006110 if (Args.hasArg(options::OPT_rdynamic))
6111 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006112 CmdArgs.push_back("--eh-frame-hdr");
6113 if (Args.hasArg(options::OPT_shared)) {
6114 CmdArgs.push_back("-Bshareable");
6115 } else {
6116 CmdArgs.push_back("-dynamic-linker");
6117 CmdArgs.push_back("/libexec/ld-elf.so.1");
6118 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006119 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6120 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006121 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6122 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6123 CmdArgs.push_back("--hash-style=both");
6124 }
6125 }
6126 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006127 }
6128
6129 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6130 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006131 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006132 CmdArgs.push_back("-m");
6133 CmdArgs.push_back("elf_i386_fbsd");
6134 }
6135
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006136 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006137 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006138 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006139 }
6140
Daniel Dunbarb440f562010-08-02 02:38:21 +00006141 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006142 CmdArgs.push_back("-o");
6143 CmdArgs.push_back(Output.getFilename());
6144 } else {
6145 assert(Output.isNothing() && "Invalid output.");
6146 }
6147
6148 if (!Args.hasArg(options::OPT_nostdlib) &&
6149 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006150 const char *crt1 = NULL;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006151 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006152 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006153 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006154 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006155 crt1 = "Scrt1.o";
6156 else
6157 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006158 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006159 if (crt1)
6160 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6161
6162 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6163
6164 const char *crtbegin = NULL;
6165 if (Args.hasArg(options::OPT_static))
6166 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006167 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006168 crtbegin = "crtbeginS.o";
6169 else
6170 crtbegin = "crtbegin.o";
6171
6172 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006173 }
6174
6175 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006176 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00006177 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6178 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006179 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006180 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6181 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006182 Args.AddAllArgs(CmdArgs, options::OPT_s);
6183 Args.AddAllArgs(CmdArgs, options::OPT_t);
6184 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6185 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006186
Alp Tokerce365ca2013-12-02 12:43:03 +00006187 if (D.IsUsingLTO(Args))
6188 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006189
Roman Divackyafe2f232012-08-28 15:09:03 +00006190 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006191
6192 if (!Args.hasArg(options::OPT_nostdlib) &&
6193 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006194 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006195 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006196 if (Args.hasArg(options::OPT_pg))
6197 CmdArgs.push_back("-lm_p");
6198 else
6199 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006200 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006201 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6202 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006203 if (Args.hasArg(options::OPT_pg))
6204 CmdArgs.push_back("-lgcc_p");
6205 else
6206 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006207 if (Args.hasArg(options::OPT_static)) {
6208 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006209 } else if (Args.hasArg(options::OPT_pg)) {
6210 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006211 } else {
6212 CmdArgs.push_back("--as-needed");
6213 CmdArgs.push_back("-lgcc_s");
6214 CmdArgs.push_back("--no-as-needed");
6215 }
6216
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006217 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006218 if (Args.hasArg(options::OPT_pg))
6219 CmdArgs.push_back("-lpthread_p");
6220 else
6221 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006222 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006223
Roman Divacky66f22762011-02-10 16:59:40 +00006224 if (Args.hasArg(options::OPT_pg)) {
6225 if (Args.hasArg(options::OPT_shared))
6226 CmdArgs.push_back("-lc");
6227 else
6228 CmdArgs.push_back("-lc_p");
6229 CmdArgs.push_back("-lgcc_p");
6230 } else {
6231 CmdArgs.push_back("-lc");
6232 CmdArgs.push_back("-lgcc");
6233 }
6234
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006235 if (Args.hasArg(options::OPT_static)) {
6236 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006237 } else if (Args.hasArg(options::OPT_pg)) {
6238 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006239 } else {
6240 CmdArgs.push_back("--as-needed");
6241 CmdArgs.push_back("-lgcc_s");
6242 CmdArgs.push_back("--no-as-needed");
6243 }
6244 }
6245
6246 if (!Args.hasArg(options::OPT_nostdlib) &&
6247 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006248 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006249 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006250 else
6251 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006252 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006253 }
6254
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006255 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6256
Alexey Samsonov7811d192014-02-20 13:57:37 +00006257 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006258
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006259 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006260 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006261 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006262}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006263
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006264void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6265 const InputInfo &Output,
6266 const InputInfoList &Inputs,
6267 const ArgList &Args,
6268 const char *LinkingOutput) const {
6269 ArgStringList CmdArgs;
6270
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006271 // GNU as needs different flags for creating the correct output format
6272 // on architectures with different ABIs or optional feature sets.
6273 switch (getToolChain().getArch()) {
6274 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006275 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006276 break;
6277 case llvm::Triple::arm:
6278 case llvm::Triple::thumb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006279 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006280 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006281 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006282 }
6283
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006284 case llvm::Triple::mips:
6285 case llvm::Triple::mipsel:
6286 case llvm::Triple::mips64:
6287 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006288 StringRef CPUName;
6289 StringRef ABIName;
6290 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6291
6292 CmdArgs.push_back("-march");
6293 CmdArgs.push_back(CPUName.data());
6294
6295 CmdArgs.push_back("-mabi");
6296 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6297
6298 if (getToolChain().getArch() == llvm::Triple::mips ||
6299 getToolChain().getArch() == llvm::Triple::mips64)
6300 CmdArgs.push_back("-EB");
6301 else
6302 CmdArgs.push_back("-EL");
6303
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006304 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006305 break;
6306 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006307
6308 case llvm::Triple::sparc:
6309 CmdArgs.push_back("-32");
6310 addAssemblerKPIC(Args, CmdArgs);
6311 break;
6312
6313 case llvm::Triple::sparcv9:
6314 CmdArgs.push_back("-64");
6315 CmdArgs.push_back("-Av9");
6316 addAssemblerKPIC(Args, CmdArgs);
6317 break;
6318
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006319 default:
6320 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006321 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006322
6323 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6324 options::OPT_Xassembler);
6325
6326 CmdArgs.push_back("-o");
6327 CmdArgs.push_back(Output.getFilename());
6328
6329 for (InputInfoList::const_iterator
6330 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6331 const InputInfo &II = *it;
6332 CmdArgs.push_back(II.getFilename());
6333 }
6334
David Chisnallddbd68f2011-09-27 22:03:18 +00006335 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006336 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6337}
6338
6339void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6340 const InputInfo &Output,
6341 const InputInfoList &Inputs,
6342 const ArgList &Args,
6343 const char *LinkingOutput) const {
6344 const Driver &D = getToolChain().getDriver();
6345 ArgStringList CmdArgs;
6346
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006347 if (!D.SysRoot.empty())
6348 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6349
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006350 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006351 if (Args.hasArg(options::OPT_static)) {
6352 CmdArgs.push_back("-Bstatic");
6353 } else {
6354 if (Args.hasArg(options::OPT_rdynamic))
6355 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006356 if (Args.hasArg(options::OPT_shared)) {
6357 CmdArgs.push_back("-Bshareable");
6358 } else {
6359 CmdArgs.push_back("-dynamic-linker");
6360 CmdArgs.push_back("/libexec/ld.elf_so");
6361 }
6362 }
6363
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006364 // Many NetBSD architectures support more than one ABI.
6365 // Determine the correct emulation for ld.
6366 switch (getToolChain().getArch()) {
6367 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006368 CmdArgs.push_back("-m");
6369 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006370 break;
6371 case llvm::Triple::arm:
6372 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006373 CmdArgs.push_back("-m");
6374 switch (getToolChain().getTriple().getEnvironment()) {
6375 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006376 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006377 CmdArgs.push_back("armelf_nbsd_eabi");
6378 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006379 case llvm::Triple::EABIHF:
6380 case llvm::Triple::GNUEABIHF:
6381 CmdArgs.push_back("armelf_nbsd_eabihf");
6382 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006383 default:
6384 CmdArgs.push_back("armelf_nbsd");
6385 break;
6386 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006387 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006388 case llvm::Triple::mips64:
6389 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006390 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006391 CmdArgs.push_back("-m");
6392 if (getToolChain().getArch() == llvm::Triple::mips64)
6393 CmdArgs.push_back("elf32btsmip");
6394 else
6395 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006396 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006397 CmdArgs.push_back("-m");
6398 if (getToolChain().getArch() == llvm::Triple::mips64)
6399 CmdArgs.push_back("elf64btsmip");
6400 else
6401 CmdArgs.push_back("elf64ltsmip");
6402 }
6403 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006404
6405 case llvm::Triple::sparc:
6406 CmdArgs.push_back("-m");
6407 CmdArgs.push_back("elf32_sparc");
6408 break;
6409
6410 case llvm::Triple::sparcv9:
6411 CmdArgs.push_back("-m");
6412 CmdArgs.push_back("elf64_sparc");
6413 break;
6414
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006415 default:
6416 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006417 }
6418
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006419 if (Output.isFilename()) {
6420 CmdArgs.push_back("-o");
6421 CmdArgs.push_back(Output.getFilename());
6422 } else {
6423 assert(Output.isNothing() && "Invalid output.");
6424 }
6425
6426 if (!Args.hasArg(options::OPT_nostdlib) &&
6427 !Args.hasArg(options::OPT_nostartfiles)) {
6428 if (!Args.hasArg(options::OPT_shared)) {
6429 CmdArgs.push_back(Args.MakeArgString(
6430 getToolChain().GetFilePath("crt0.o")));
6431 CmdArgs.push_back(Args.MakeArgString(
6432 getToolChain().GetFilePath("crti.o")));
6433 CmdArgs.push_back(Args.MakeArgString(
6434 getToolChain().GetFilePath("crtbegin.o")));
6435 } else {
6436 CmdArgs.push_back(Args.MakeArgString(
6437 getToolChain().GetFilePath("crti.o")));
6438 CmdArgs.push_back(Args.MakeArgString(
6439 getToolChain().GetFilePath("crtbeginS.o")));
6440 }
6441 }
6442
6443 Args.AddAllArgs(CmdArgs, options::OPT_L);
6444 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6445 Args.AddAllArgs(CmdArgs, options::OPT_e);
6446 Args.AddAllArgs(CmdArgs, options::OPT_s);
6447 Args.AddAllArgs(CmdArgs, options::OPT_t);
6448 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6449 Args.AddAllArgs(CmdArgs, options::OPT_r);
6450
6451 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6452
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006453 unsigned Major, Minor, Micro;
6454 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6455 bool useLibgcc = true;
6456 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006457 switch(getToolChain().getArch()) {
6458 case llvm::Triple::x86:
6459 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006460 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006461 break;
6462 default:
6463 break;
6464 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006465 }
6466
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006467 if (!Args.hasArg(options::OPT_nostdlib) &&
6468 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006469 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006470 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6471 CmdArgs.push_back("-lm");
6472 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006473 if (Args.hasArg(options::OPT_pthread))
6474 CmdArgs.push_back("-lpthread");
6475 CmdArgs.push_back("-lc");
6476
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006477 if (useLibgcc) {
6478 if (Args.hasArg(options::OPT_static)) {
6479 // libgcc_eh depends on libc, so resolve as much as possible,
6480 // pull in any new requirements from libc and then get the rest
6481 // of libgcc.
6482 CmdArgs.push_back("-lgcc_eh");
6483 CmdArgs.push_back("-lc");
6484 CmdArgs.push_back("-lgcc");
6485 } else {
6486 CmdArgs.push_back("-lgcc");
6487 CmdArgs.push_back("--as-needed");
6488 CmdArgs.push_back("-lgcc_s");
6489 CmdArgs.push_back("--no-as-needed");
6490 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006491 }
6492 }
6493
6494 if (!Args.hasArg(options::OPT_nostdlib) &&
6495 !Args.hasArg(options::OPT_nostartfiles)) {
6496 if (!Args.hasArg(options::OPT_shared))
6497 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6498 "crtend.o")));
6499 else
6500 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6501 "crtendS.o")));
6502 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6503 "crtn.o")));
6504 }
6505
Alexey Samsonov7811d192014-02-20 13:57:37 +00006506 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006507
Rafael Espindola236db462013-11-09 20:07:19 +00006508 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006509 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6510}
6511
Thomas Schwinge4e555262013-03-28 19:04:25 +00006512void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6513 const InputInfo &Output,
6514 const InputInfoList &Inputs,
6515 const ArgList &Args,
6516 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006517 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006518 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006519
6520 // Add --32/--64 to make sure we get the format we want.
6521 // This is incomplete
6522 if (getToolChain().getArch() == llvm::Triple::x86) {
6523 CmdArgs.push_back("--32");
6524 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6525 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006526 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6527 CmdArgs.push_back("-a32");
6528 CmdArgs.push_back("-mppc");
6529 CmdArgs.push_back("-many");
6530 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6531 CmdArgs.push_back("-a64");
6532 CmdArgs.push_back("-mppc64");
6533 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006534 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6535 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006536 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006537 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006538 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006539 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6540 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006541 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006542 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006543 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6544 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006545 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006546 NeedsKPIC = true;
Rafael Espindola92b00932010-08-10 00:25:48 +00006547 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006548 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006549 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6550 CmdArgs.push_back("-mfpu=neon");
Bernard Ogdena58ef052013-10-24 18:32:41 +00006551 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6552 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006553
Tim Northover9c7e0352013-12-12 11:55:52 +00006554 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6555 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006556 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006557
6558 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006559
6560 // FIXME: remove krait check when GNU tools support krait cpu
6561 // for now replace it with -march=armv7-a to avoid a lower
6562 // march from being picked in the absence of a cpu flag.
6563 Arg *A;
6564 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6565 StringRef(A->getValue()) == "krait")
6566 CmdArgs.push_back("-march=armv7-a");
6567 else
6568 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006569 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006570 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6571 getToolChain().getArch() == llvm::Triple::mipsel ||
6572 getToolChain().getArch() == llvm::Triple::mips64 ||
6573 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006574 StringRef CPUName;
6575 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006576 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006577
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006578 CmdArgs.push_back("-march");
6579 CmdArgs.push_back(CPUName.data());
6580
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006581 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006582 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006583
6584 if (getToolChain().getArch() == llvm::Triple::mips ||
6585 getToolChain().getArch() == llvm::Triple::mips64)
6586 CmdArgs.push_back("-EB");
6587 else
6588 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006589
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006590 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6591 if (StringRef(A->getValue()) == "2008")
6592 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6593 }
6594
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006595 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006596 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6597 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6598 options::OPT_mno_micromips);
6599 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6600 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6601
Simon Atanasyanbd986632013-11-26 11:58:04 +00006602 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6603 // Do not use AddLastArg because not all versions of MIPS assembler
6604 // support -mmsa / -mno-msa options.
6605 if (A->getOption().matches(options::OPT_mmsa))
6606 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6607 }
6608
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006609 NeedsKPIC = true;
6610 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6611 // Always pass an -march option, since our default of z10 is later
6612 // than the GNU assembler's default.
6613 StringRef CPUName = getSystemZTargetCPU(Args);
6614 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6615 }
6616
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006617 if (NeedsKPIC)
6618 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006619
6620 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6621 options::OPT_Xassembler);
6622
6623 CmdArgs.push_back("-o");
6624 CmdArgs.push_back(Output.getFilename());
6625
6626 for (InputInfoList::const_iterator
6627 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6628 const InputInfo &II = *it;
6629 CmdArgs.push_back(II.getFilename());
6630 }
6631
6632 const char *Exec =
6633 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6634 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006635
6636 // Handle the debug info splitting at object creation time if we're
6637 // creating an object.
6638 // TODO: Currently only works on linux with newer objcopy.
6639 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006640 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006641 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6642 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006643}
6644
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006645static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006646 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006647 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006648 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6649 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006650 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006651 CmdArgs.push_back("-lgcc");
6652
Logan Chien3d3373c2012-11-19 12:04:11 +00006653 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006654 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006655 CmdArgs.push_back("-lgcc");
6656 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006657 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006658 CmdArgs.push_back("--as-needed");
6659 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006660 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006661 CmdArgs.push_back("--no-as-needed");
6662 }
6663
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006664 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006665 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006666 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006667 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006668
6669 // According to Android ABI, we have to link with libdl if we are
6670 // linking with non-static libgcc.
6671 //
6672 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6673 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6674 if (isAndroid && !StaticLibgcc)
6675 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006676}
6677
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006678static StringRef getLinuxDynamicLinker(const ArgList &Args,
6679 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006680 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6681 if (ToolChain.getTriple().isArch64Bit())
6682 return "/system/bin/linker64";
6683 else
6684 return "/system/bin/linker";
6685 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6686 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006687 return "/lib/ld-linux.so.2";
6688 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6689 return "/lib/ld-linux-aarch64.so.1";
Christian Pirkera74c7912014-03-14 12:15:45 +00006690 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6691 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006692 else if (ToolChain.getArch() == llvm::Triple::arm ||
6693 ToolChain.getArch() == llvm::Triple::thumb) {
6694 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6695 return "/lib/ld-linux-armhf.so.3";
6696 else
6697 return "/lib/ld-linux.so.3";
6698 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6699 ToolChain.getArch() == llvm::Triple::mipsel)
6700 return "/lib/ld.so.1";
6701 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6702 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006703 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006704 return "/lib32/ld.so.1";
6705 else
6706 return "/lib64/ld.so.1";
6707 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6708 return "/lib/ld.so.1";
6709 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidt778d3872013-07-26 01:36:11 +00006710 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006711 ToolChain.getArch() == llvm::Triple::systemz)
6712 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006713 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6714 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006715 else
6716 return "/lib64/ld-linux-x86-64.so.2";
6717}
6718
Renato Golinc4b49242014-02-13 10:01:16 +00006719static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6720 ArgStringList &CmdArgs, const ArgList &Args) {
6721 // Make use of compiler-rt if --rtlib option is used
6722 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6723
6724 switch(RLT) {
6725 case ToolChain::RLT_CompilerRT:
6726 addClangRTLinux(TC, Args, CmdArgs);
6727 break;
6728 case ToolChain::RLT_Libgcc:
6729 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6730 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006731 }
6732}
6733
Thomas Schwinge4e555262013-03-28 19:04:25 +00006734void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6735 const InputInfo &Output,
6736 const InputInfoList &Inputs,
6737 const ArgList &Args,
6738 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006739 const toolchains::Linux& ToolChain =
6740 static_cast<const toolchains::Linux&>(getToolChain());
6741 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006742 const bool isAndroid =
6743 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006744 const bool IsPIE =
6745 !Args.hasArg(options::OPT_shared) &&
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006746 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006747
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006748 ArgStringList CmdArgs;
6749
Rafael Espindolad1002f62010-11-15 18:28:16 +00006750 // Silence warning for "clang -g foo.o -o foo"
6751 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006752 // and "clang -emit-llvm foo.o -o foo"
6753 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00006754 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00006755 // handled somewhere else.
6756 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00006757
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006758 if (!D.SysRoot.empty())
6759 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006760
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006761 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00006762 CmdArgs.push_back("-pie");
6763
Rafael Espindola1c76c592010-11-07 22:57:16 +00006764 if (Args.hasArg(options::OPT_rdynamic))
6765 CmdArgs.push_back("-export-dynamic");
6766
Rafael Espindola34d77dc2010-11-11 19:34:42 +00006767 if (Args.hasArg(options::OPT_s))
6768 CmdArgs.push_back("-s");
6769
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006770 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6771 e = ToolChain.ExtraOpts.end();
6772 i != e; ++i)
6773 CmdArgs.push_back(i->c_str());
6774
6775 if (!Args.hasArg(options::OPT_static)) {
6776 CmdArgs.push_back("--eh-frame-hdr");
6777 }
6778
6779 CmdArgs.push_back("-m");
6780 if (ToolChain.getArch() == llvm::Triple::x86)
6781 CmdArgs.push_back("elf_i386");
Tim Northover9bb857a2013-01-31 12:13:10 +00006782 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6783 CmdArgs.push_back("aarch64linux");
Christian Pirkera74c7912014-03-14 12:15:45 +00006784 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
6785 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00006786 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00006787 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006788 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43d47cc2011-04-05 22:04:27 +00006789 else if (ToolChain.getArch() == llvm::Triple::ppc)
6790 CmdArgs.push_back("elf32ppclinux");
6791 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6792 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006793 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
6794 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00006795 else if (ToolChain.getArch() == llvm::Triple::sparc)
6796 CmdArgs.push_back("elf32_sparc");
6797 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6798 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00006799 else if (ToolChain.getArch() == llvm::Triple::mips)
6800 CmdArgs.push_back("elf32btsmip");
6801 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6802 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006803 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006804 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006805 CmdArgs.push_back("elf32btsmipn32");
6806 else
6807 CmdArgs.push_back("elf64btsmip");
6808 }
6809 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006810 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00006811 CmdArgs.push_back("elf32ltsmipn32");
6812 else
6813 CmdArgs.push_back("elf64ltsmip");
6814 }
Ulrich Weigand47445072013-05-06 16:26:41 +00006815 else if (ToolChain.getArch() == llvm::Triple::systemz)
6816 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006817 else
6818 CmdArgs.push_back("elf_x86_64");
6819
6820 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00006821 if (ToolChain.getArch() == llvm::Triple::arm ||
6822 ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006823 CmdArgs.push_back("-Bstatic");
6824 else
6825 CmdArgs.push_back("-static");
6826 } else if (Args.hasArg(options::OPT_shared)) {
6827 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00006828 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006829 CmdArgs.push_back("-Bsymbolic");
6830 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006831 }
6832
6833 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00006834 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006835 (!Args.hasArg(options::OPT_static) &&
6836 !Args.hasArg(options::OPT_shared))) {
6837 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006838 CmdArgs.push_back(Args.MakeArgString(
6839 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006840 }
6841
6842 CmdArgs.push_back("-o");
6843 CmdArgs.push_back(Output.getFilename());
6844
Rafael Espindola81937ec2010-12-01 01:52:43 +00006845 if (!Args.hasArg(options::OPT_nostdlib) &&
6846 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006847 if (!isAndroid) {
6848 const char *crt1 = NULL;
6849 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00006850 if (Args.hasArg(options::OPT_pg))
6851 crt1 = "gcrt1.o";
6852 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006853 crt1 = "Scrt1.o";
6854 else
6855 crt1 = "crt1.o";
6856 }
6857 if (crt1)
6858 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006859
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006860 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6861 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006862
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006863 const char *crtbegin;
6864 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006865 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006866 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006867 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006868 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006869 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006870 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006871 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006872 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00006873
6874 // Add crtfastmath.o if available and fast math is enabled.
6875 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006876 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006877
6878 Args.AddAllArgs(CmdArgs, options::OPT_L);
6879
6880 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6881
Roman Divackyee8188a2011-03-01 17:53:14 +00006882 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6883 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006884 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006885
Alp Tokerce365ca2013-12-02 12:43:03 +00006886 if (D.IsUsingLTO(Args))
6887 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00006888
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00006889 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6890 CmdArgs.push_back("--no-demangle");
6891
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006892 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6893
Alexey Samsonovce8ab102014-02-25 12:43:43 +00006894 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006895 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00006896 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00006897
Hans Wennborg70850d82013-07-18 20:29:38 +00006898 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00006899 !Args.hasArg(options::OPT_nostdlib) &&
6900 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00006901 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6902 !Args.hasArg(options::OPT_static);
6903 if (OnlyLibstdcxxStatic)
6904 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006905 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00006906 if (OnlyLibstdcxxStatic)
6907 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006908 CmdArgs.push_back("-lm");
6909 }
6910
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006911 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00006912 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6913 if (Args.hasArg(options::OPT_static))
6914 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00006915
Alexey Bataev186b28a2014-03-06 05:43:53 +00006916 LibOpenMP UsedOpenMPLib = LibUnknown;
6917 if (Args.hasArg(options::OPT_fopenmp)) {
6918 UsedOpenMPLib = LibGOMP;
6919 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
6920 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
6921 .Case("libgomp", LibGOMP)
6922 .Case("libiomp5", LibIOMP5)
6923 .Default(LibUnknown);
6924 if (UsedOpenMPLib == LibUnknown)
6925 D.Diag(diag::err_drv_unsupported_option_argument)
6926 << A->getOption().getName() << A->getValue();
6927 }
6928 switch (UsedOpenMPLib) {
6929 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00006930 CmdArgs.push_back("-lgomp");
6931
Alp Tokerf6a24ce2013-12-05 16:25:25 +00006932 // FIXME: Exclude this for platforms with libgomp that don't require
6933 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00006934 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00006935 break;
6936 case LibIOMP5:
6937 CmdArgs.push_back("-liomp5");
6938 break;
6939 case LibUnknown:
6940 break;
Chandler Carruth01538002013-01-17 13:19:29 +00006941 }
Renato Golinc4b49242014-02-13 10:01:16 +00006942 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006943
Chandler Carruth94a32012012-05-14 18:31:18 +00006944 if (Args.hasArg(options::OPT_pthread) ||
Alexey Bataev648250a2014-03-07 07:43:52 +00006945 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown)
Chandler Carruth94a32012012-05-14 18:31:18 +00006946 CmdArgs.push_back("-lpthread");
6947
6948 CmdArgs.push_back("-lc");
6949
6950 if (Args.hasArg(options::OPT_static))
6951 CmdArgs.push_back("--end-group");
6952 else
Renato Golinc4b49242014-02-13 10:01:16 +00006953 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00006954 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00006955
Rafael Espindola81937ec2010-12-01 01:52:43 +00006956 if (!Args.hasArg(options::OPT_nostartfiles)) {
6957 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006958 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006959 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006960 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00006961 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00006962 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006963 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00006964
Rafael Espindola81937ec2010-12-01 01:52:43 +00006965 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006966 if (!isAndroid)
6967 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00006968 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006969 }
6970
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006971 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6972}
Rafael Espindola92b00932010-08-10 00:25:48 +00006973
Chris Lattner3e2ee142010-07-07 16:01:42 +00006974void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006975 const InputInfo &Output,
6976 const InputInfoList &Inputs,
6977 const ArgList &Args,
6978 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006979 ArgStringList CmdArgs;
6980
6981 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6982 options::OPT_Xassembler);
6983
6984 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006985 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006986
6987 for (InputInfoList::const_iterator
6988 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6989 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006990 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00006991 }
6992
6993 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00006994 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006995 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006996}
6997
6998void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006999 const InputInfo &Output,
7000 const InputInfoList &Inputs,
7001 const ArgList &Args,
7002 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007003 const Driver &D = getToolChain().getDriver();
7004 ArgStringList CmdArgs;
7005
Daniel Dunbarb440f562010-08-02 02:38:21 +00007006 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007007 CmdArgs.push_back("-o");
7008 CmdArgs.push_back(Output.getFilename());
7009 } else {
7010 assert(Output.isNothing() && "Invalid output.");
7011 }
7012
7013 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007014 !Args.hasArg(options::OPT_nostartfiles)) {
7015 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7016 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7017 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7018 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7019 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007020
7021 Args.AddAllArgs(CmdArgs, options::OPT_L);
7022 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7023 Args.AddAllArgs(CmdArgs, options::OPT_e);
7024
Daniel Dunbar54423b22010-09-17 00:24:54 +00007025 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007026
Alexey Samsonov7811d192014-02-20 13:57:37 +00007027 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007028
Chris Lattner3e2ee142010-07-07 16:01:42 +00007029 if (!Args.hasArg(options::OPT_nostdlib) &&
7030 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007031 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007032 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007033 CmdArgs.push_back("-lm");
7034 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007035 }
7036
7037 if (!Args.hasArg(options::OPT_nostdlib) &&
7038 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007039 if (Args.hasArg(options::OPT_pthread))
7040 CmdArgs.push_back("-lpthread");
7041 CmdArgs.push_back("-lc");
7042 CmdArgs.push_back("-lCompilerRT-Generic");
7043 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7044 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007045 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007046 }
7047
Rafael Espindola236db462013-11-09 20:07:19 +00007048 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007049 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007050}
7051
Daniel Dunbarcc912342009-05-02 18:28:39 +00007052/// DragonFly Tools
7053
7054// For now, DragonFly Assemble does just about the same as for
7055// FreeBSD, but this may change soon.
7056void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007057 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007058 const InputInfoList &Inputs,
7059 const ArgList &Args,
7060 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007061 ArgStringList CmdArgs;
7062
7063 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7064 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007065 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007066 CmdArgs.push_back("--32");
7067
7068 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7069 options::OPT_Xassembler);
7070
7071 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007072 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007073
7074 for (InputInfoList::const_iterator
7075 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7076 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007077 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007078 }
7079
7080 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007081 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007082 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007083}
7084
7085void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007086 const InputInfo &Output,
7087 const InputInfoList &Inputs,
7088 const ArgList &Args,
7089 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007090 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007091 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007092 ArgStringList CmdArgs;
7093
John McCall65b8da02013-04-11 22:55:55 +00007094 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7095 UseGCC47 = false;
7096
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007097 if (!D.SysRoot.empty())
7098 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7099
John McCall65b8da02013-04-11 22:55:55 +00007100 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007101 if (Args.hasArg(options::OPT_static)) {
7102 CmdArgs.push_back("-Bstatic");
7103 } else {
John McCall65b8da02013-04-11 22:55:55 +00007104 if (Args.hasArg(options::OPT_rdynamic))
7105 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007106 if (Args.hasArg(options::OPT_shared))
7107 CmdArgs.push_back("-Bshareable");
7108 else {
7109 CmdArgs.push_back("-dynamic-linker");
7110 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7111 }
John McCall65b8da02013-04-11 22:55:55 +00007112 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007113 }
7114
7115 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7116 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007117 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007118 CmdArgs.push_back("-m");
7119 CmdArgs.push_back("elf_i386");
7120 }
7121
Daniel Dunbarb440f562010-08-02 02:38:21 +00007122 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007123 CmdArgs.push_back("-o");
7124 CmdArgs.push_back(Output.getFilename());
7125 } else {
7126 assert(Output.isNothing() && "Invalid output.");
7127 }
7128
7129 if (!Args.hasArg(options::OPT_nostdlib) &&
7130 !Args.hasArg(options::OPT_nostartfiles)) {
7131 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007132 if (Args.hasArg(options::OPT_pg))
7133 CmdArgs.push_back(Args.MakeArgString(
7134 getToolChain().GetFilePath("gcrt1.o")));
7135 else {
7136 if (Args.hasArg(options::OPT_pie))
7137 CmdArgs.push_back(Args.MakeArgString(
7138 getToolChain().GetFilePath("Scrt1.o")));
7139 else
7140 CmdArgs.push_back(Args.MakeArgString(
7141 getToolChain().GetFilePath("crt1.o")));
7142 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007143 }
John McCall65b8da02013-04-11 22:55:55 +00007144 CmdArgs.push_back(Args.MakeArgString(
7145 getToolChain().GetFilePath("crti.o")));
7146 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7147 CmdArgs.push_back(Args.MakeArgString(
7148 getToolChain().GetFilePath("crtbeginS.o")));
7149 else
7150 CmdArgs.push_back(Args.MakeArgString(
7151 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007152 }
7153
7154 Args.AddAllArgs(CmdArgs, options::OPT_L);
7155 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7156 Args.AddAllArgs(CmdArgs, options::OPT_e);
7157
Daniel Dunbar54423b22010-09-17 00:24:54 +00007158 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007159
7160 if (!Args.hasArg(options::OPT_nostdlib) &&
7161 !Args.hasArg(options::OPT_nodefaultlibs)) {
7162 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7163 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007164 if (UseGCC47)
7165 CmdArgs.push_back("-L/usr/lib/gcc47");
7166 else
7167 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007168
7169 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007170 if (UseGCC47) {
7171 CmdArgs.push_back("-rpath");
7172 CmdArgs.push_back("/usr/lib/gcc47");
7173 } else {
7174 CmdArgs.push_back("-rpath");
7175 CmdArgs.push_back("/usr/lib/gcc44");
7176 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007177 }
7178
Hans Wennborg70850d82013-07-18 20:29:38 +00007179 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007180 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007181 CmdArgs.push_back("-lm");
7182 }
7183
Daniel Dunbarcc912342009-05-02 18:28:39 +00007184 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007185 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007186
7187 if (!Args.hasArg(options::OPT_nolibc)) {
7188 CmdArgs.push_back("-lc");
7189 }
7190
John McCall65b8da02013-04-11 22:55:55 +00007191 if (UseGCC47) {
7192 if (Args.hasArg(options::OPT_static) ||
7193 Args.hasArg(options::OPT_static_libgcc)) {
7194 CmdArgs.push_back("-lgcc");
7195 CmdArgs.push_back("-lgcc_eh");
7196 } else {
7197 if (Args.hasArg(options::OPT_shared_libgcc)) {
7198 CmdArgs.push_back("-lgcc_pic");
7199 if (!Args.hasArg(options::OPT_shared))
7200 CmdArgs.push_back("-lgcc");
7201 } else {
7202 CmdArgs.push_back("-lgcc");
7203 CmdArgs.push_back("--as-needed");
7204 CmdArgs.push_back("-lgcc_pic");
7205 CmdArgs.push_back("--no-as-needed");
7206 }
7207 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007208 } else {
John McCall65b8da02013-04-11 22:55:55 +00007209 if (Args.hasArg(options::OPT_shared)) {
7210 CmdArgs.push_back("-lgcc_pic");
7211 } else {
7212 CmdArgs.push_back("-lgcc");
7213 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007214 }
7215 }
7216
7217 if (!Args.hasArg(options::OPT_nostdlib) &&
7218 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007219 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007220 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007221 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007222 else
7223 CmdArgs.push_back(Args.MakeArgString(
7224 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007225 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007226 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007227 }
7228
Alexey Samsonov7811d192014-02-20 13:57:37 +00007229 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007230
Daniel Dunbarcc912342009-05-02 18:28:39 +00007231 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00007232 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007233 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007234}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007235
7236void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7237 const InputInfo &Output,
7238 const InputInfoList &Inputs,
7239 const ArgList &Args,
7240 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007241 ArgStringList CmdArgs;
7242
7243 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007244 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7245 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007246 } else {
7247 assert(Output.isNothing() && "Invalid output.");
7248 }
7249
7250 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007251 !Args.hasArg(options::OPT_nostartfiles) &&
7252 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007253 CmdArgs.push_back("-defaultlib:libcmt");
7254 }
7255
7256 CmdArgs.push_back("-nologo");
7257
Hans Wennborgf1a74252013-09-10 20:18:04 +00007258 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7259
7260 if (DLL) {
7261 CmdArgs.push_back(Args.MakeArgString("-dll"));
7262
7263 SmallString<128> ImplibName(Output.getFilename());
7264 llvm::sys::path::replace_extension(ImplibName, "lib");
7265 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7266 ImplibName.str()));
7267 }
7268
Peter Collingbourne32701642013-11-01 18:16:25 +00007269 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007270 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007271 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborg65f17522013-08-27 18:10:21 +00007272 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007273 llvm::sys::path::append(LibSanitizer, "lib", "windows");
7274 if (DLL) {
Timur Iskhodzhanov3b6adcb62013-09-11 11:45:31 +00007275 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
Hans Wennborgf1a74252013-09-10 20:18:04 +00007276 } else {
7277 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
7278 }
7279 // FIXME: Handle 64-bit.
Hans Wennborg65f17522013-08-27 18:10:21 +00007280 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7281 }
7282
Michael J. Spencere2f49362012-06-18 16:56:04 +00007283 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007284 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007285
7286 // Add filenames immediately.
7287 for (InputInfoList::const_iterator
7288 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7289 if (it->isFilename())
7290 CmdArgs.push_back(it->getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007291 else
7292 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007293 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007294
7295 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007296 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007297 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7298}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007299
7300void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7301 const InputInfo &Output,
7302 const InputInfoList &Inputs,
7303 const ArgList &Args,
7304 const char *LinkingOutput) const {
7305 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7306}
7307
Hans Wennborg188382e2013-09-20 18:16:35 +00007308// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7309// If one cannot be found, return FallbackName.
7310// We do this special search to prevent clang-cl from falling back onto itself
7311// if it's available as cl.exe on the path.
7312static std::string FindFallback(const char *FallbackName,
7313 const char *ClangProgramPath) {
7314 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7315 if (!OptPath.hasValue())
7316 return FallbackName;
7317
7318#ifdef LLVM_ON_WIN32
7319 const StringRef PathSeparators = ";";
7320#else
7321 const StringRef PathSeparators = ":";
7322#endif
7323
7324 SmallVector<StringRef, 8> PathSegments;
7325 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7326
7327 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7328 const StringRef &PathSegment = PathSegments[i];
7329 if (PathSegment.empty())
7330 continue;
7331
7332 SmallString<128> FilePath(PathSegment);
7333 llvm::sys::path::append(FilePath, FallbackName);
7334 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7335 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7336 return FilePath.str();
7337 }
7338
7339 return FallbackName;
7340}
7341
Hans Wennborg87cfa712013-09-19 20:32:16 +00007342Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7343 const InputInfo &Output,
7344 const InputInfoList &Inputs,
7345 const ArgList &Args,
7346 const char *LinkingOutput) const {
7347 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007348 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007349 CmdArgs.push_back("/c"); // Compile only.
7350 CmdArgs.push_back("/W0"); // No warnings.
7351
7352 // The goal is to be able to invoke this tool correctly based on
7353 // any flag accepted by clang-cl.
7354
7355 // These are spelled the same way in clang and cl.exe,.
7356 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7357 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007358
7359 // Optimization level.
7360 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7361 if (A->getOption().getID() == options::OPT_O0) {
7362 CmdArgs.push_back("/Od");
7363 } else {
7364 StringRef OptLevel = A->getValue();
7365 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7366 A->render(Args, CmdArgs);
7367 else if (OptLevel == "3")
7368 CmdArgs.push_back("/Ox");
7369 }
7370 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007371
7372 // Flags for which clang-cl have an alias.
7373 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7374
7375 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7376 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7377 : "/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007378 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7379 options::OPT_fno_function_sections))
7380 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7381 ? "/Gy"
7382 : "/Gy-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007383 if (Args.hasArg(options::OPT_fsyntax_only))
7384 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007385 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7386 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007387
Hans Wennborg260ff402013-09-27 17:54:18 +00007388 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7389 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7390 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7391
Hans Wennborg87cfa712013-09-19 20:32:16 +00007392 // Flags that can simply be passed through.
7393 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7394 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7395
7396 // The order of these flags is relevant, so pick the last one.
7397 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7398 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7399 A->render(Args, CmdArgs);
7400
7401
7402 // Input filename.
7403 assert(Inputs.size() == 1);
7404 const InputInfo &II = Inputs[0];
7405 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7406 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7407 if (II.isFilename())
7408 CmdArgs.push_back(II.getFilename());
7409 else
7410 II.getInputArg().renderAsInput(Args, CmdArgs);
7411
7412 // Output filename.
7413 assert(Output.getType() == types::TY_Object);
7414 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7415 Output.getFilename());
7416 CmdArgs.push_back(Fo);
7417
Hans Wennborg188382e2013-09-20 18:16:35 +00007418 const Driver &D = getToolChain().getDriver();
7419 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg87cfa712013-09-19 20:32:16 +00007420
Hans Wennborg188382e2013-09-20 18:16:35 +00007421 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007422}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007423
7424
7425/// XCore Tools
7426// We pass assemble and link construction to the xcc tool.
7427
7428void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7429 const InputInfo &Output,
7430 const InputInfoList &Inputs,
7431 const ArgList &Args,
7432 const char *LinkingOutput) const {
7433 ArgStringList CmdArgs;
7434
7435 CmdArgs.push_back("-o");
7436 CmdArgs.push_back(Output.getFilename());
7437
7438 CmdArgs.push_back("-c");
7439
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007440 if (Args.hasArg(options::OPT_v))
7441 CmdArgs.push_back("-v");
7442
7443 if (Args.hasArg(options::OPT_g_Group))
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007444 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007445
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007446 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7447 false))
7448 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007449
7450 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7451 options::OPT_Xassembler);
7452
7453 for (InputInfoList::const_iterator
7454 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7455 const InputInfo &II = *it;
7456 CmdArgs.push_back(II.getFilename());
7457 }
7458
7459 const char *Exec =
7460 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7461 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7462}
7463
7464void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7465 const InputInfo &Output,
7466 const InputInfoList &Inputs,
7467 const ArgList &Args,
7468 const char *LinkingOutput) const {
7469 ArgStringList CmdArgs;
7470
7471 if (Output.isFilename()) {
7472 CmdArgs.push_back("-o");
7473 CmdArgs.push_back(Output.getFilename());
7474 } else {
7475 assert(Output.isNothing() && "Invalid output.");
7476 }
7477
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007478 if (Args.hasArg(options::OPT_v))
7479 CmdArgs.push_back("-v");
7480
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007481 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7482 if (EH.ShouldUseExceptionTables)
7483 CmdArgs.push_back("-fexceptions");
7484
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007485 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7486
7487 const char *Exec =
7488 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7489 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7490}